面向对象编程之接口的概念和作用
接口的特点
接口中只能存放静态常量和抽象方法
Java接口是对功能的扩展
通过实现接口，java类可以实现多实现
一个类可以同时继承（extends）一个父类并且实现（implements）多个接口
接口与接口之间可以通过使用extends来产生继承关系
接口与抽象类的区别
抽象类和具体实现之间是一种继承关系，也就是说如果采用抽象类的方式，则父类和子类在概念上应该是相同的
接口和实现类在概念上不要求相同，接口只是抽取相互之间没有关系的类的共同特征，而不去关注类之间的关系，它可以使没有层次关系的类具有要相同的行为
抽象类是对一组具有相同属性和行为的逻辑上有关系的事物的一种抽象，而接口则是对一组具有相同属性和行为的逻辑上不相关的事物的一种抽象
对于接口和抽象类的选择，反映出设计人员看待问题的不同角度。抽象类用于一组相关的事物，表示“is-a”的关系；而接口用于一组不相关的事物，表示的是“like-a”的关系
demo:
public class InterfaceDemo
{
public static void main(String[] args){
test1();
}
public static void test1(){
System.out.println("接口常量："+IAbility.number);
Person p=new Person();
Child child=new Child();
Cat cat=new Cat();
p.feed(child);
p.feed(cat);
System.out.println("——————————————————————————————————");
}
}
//不同事物同一种能力的抽象
interface IAbility{
//public static final三个关键字顺序可以随便写
int number=2;//接口中的变量，默认为公有静态常量，如：public static final int number=2;
void eat();//默认是 public abstract void eat();
}
class Person{
public void feed(IAbility iability){//使用接口来接收，越抽象越稳定
System.out.println("喂养");
iability.eat();//接口用起来与父类差不多，但意义上不一样
}
}
//implements后可写多个接口名，用,号隔开
class Child implements IAbility{
public void eat(){
System.out.println("小孩吃饭");
}
}
class Cat implements IAbility{
public void eat(){
System.out.println("小猫吃猫粮");
}
}效果：
面向接口编程
开发系统时，主体构架使用接口，接口构造系统的骨架
这样就可以通过更换接口的实现类来更换系统的功能实现
简单工厂模式
定义：专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类或接口
意图：提供一个类，由它负责根据一定的条件创建某一具体类的实例
demo:
public class FactoryDemo
{
public static void main(String[] args){
test1();
}
public static void test1(){
IFruit fruit=Factory.getFruit("苹果");
if(fruit!=null) System.out.println(fruit.get());
fruit=Factory.getFruit("桔子");
if(fruit!=null) System.out.println(fruit.get());
System.out.println("——————————————————————————————————");
}
}
//简单工厂类
class Factory{
public static IFruit getFruit(String name){
if(name.equals("苹果")){
return new Apple();
}
else if(name.equals("桔子")){
return new Orange();
}
else{
return null;
}
}
}
interface IFruit{
String get();
}
class Apple implements IFruit
{
public String get(){
return "采摘苹果";
}
}
class Orange implements IFruit
{
public String get(){
return "采摘桔子";
}
}效果：
面向对象编程之设计模式策略模式
定义：是对算法的包装，把使用算法的责任和算法本身分割开，委派给不同的对象管理。策略模式通常把一个系列的算法包装到一系列的策略里面，作为一个抽象策略类型的子类型。就是：“准备一组算法，并将每一个算法封闭起来，使得它们可以互换”
意图：针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换、策略模式 使得算法可以在不影响到客户端的情况下发生变化
demo:
public class StrategyDemo
{
public static void main(String[] args){
test1();
}
public static void test1(){
int[] array={4,7,9,5,3,2};
ISort s1=new BubbleSort();
Context context = new Context(s1);
context.sort(array);
context.printArray(array);
System.out.println("——————————————————————————————————");
int[] array2={50,7,45,32,56,2};
ISort s2=new SelectSort();
Context context2 = new Context(s2);
context2.sort(array2);
context2.printArray(array2);
System.out.println("——————————————————————————————————");
}
}
class Context{
private ISort iSort=null;
public Context(ISort iSort){
this.iSort=iSort;
}
public void sort(int[] array){
iSort.sort(array);
}
public void printArray(int[] array){
for(int i=0;i<array.length;i++){
System.out.print(array[i]+" ");
}
System.out.println();
}
}
interface ISort{
void sort(int[] array);
}
class BubbleSort implements ISort{
public void sort(int[] array){
System.out.println("冒泡排序法");
for(int i=0;i<array.length - 1;i++){
for(int j=0;j<array.length-i-1;j++){
if(array[j]>array[j+1]){
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
}
}
class SelectSort implements ISort{
public void sort(int[] array){
System.out.println("选择排序法");
int min=0;
for(int i=0;i<array.length;i++){
min=i;
for(int j=i+1;j<array.length;j++){
if(array[min]>array[j]){
min=j;
}
}
if(min!=i){
int temp=array[i];
array[i]=array[min];
array[min]=temp;
}
}
}
}效果：