java抽象类和接口

当编写一个类时，常常为该类定义一些方法，这些方法用以描述该类的行为方式。当某个父类只是知道子类应该包含怎样的方法，但无法准确的知道这些子类如何实现这些方法。

抽象方法可以满足这样的要求

一 抽象方法

抽象方法是只有方法签名，没有方法实现的方式，有抽象方法的类只能被定义成抽象类，抽象类可以没有抽象方法

1 抽象类必须用obstract修饰，抽象方法也必须使用obstract，抽象方法不能有方法体

2 抽象类不能实例化，无法用new 关键字创建抽象类实例

3 抽象类的构器不能用于创建实例，用于给子类调用

4 final和obstract只能出现其一，永远不能同时出现（obstract不能修饰成员变量和局部变量，构造器）

4 private和obstract只能出现其一，永远不能同时出现（static 可以和obstract同时修饰内部类）

public abstract class Shape{

{

System.out.println("初始化块");

}

public abstract double calPerimeter();//定义一个计算周长的抽象方法

public abstract String getType();//定义一个返回形状的抽象方法

public Shape(){}//给子类调用

public Shape(String color){

this.color=color;

}

//省略color的setter和getter方法

}

public class Triangle extends Shape

{

private double a;

private double b;

private double c;

public Triangle(String color,double a,double b,double c){

super(color);

this.setSize(a,b,c);

}

public void setSize(double a,double b,double c){

if(a>=b+c||b>=a+c||c>=a+b){

System.out.println("三角形两边之和必须大于第三边")；

return;

}

this.a=a;

this.b=b;

this.c=c;

}

//重写Shape类计算周长的抽象方法

public double calPerimeter(){

return a+b+c;

}

//重写Shape类返回类型的抽象方法

public String getType(){

return

}

}

二 抽象类

抽象类的作用，以这个抽象类作为子类的模板，从而避免子类设计的随意性。

抽象类体现的就是一种模板模式的设计

三 接口

1 抽象类是从多个类中抽象出来的模板，如果将这种抽象进行得更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（interface）

接口不能包含普通方法，接口所有方法都是抽象方法，java8允许定义默认方法，默认方法可以提供方法实现

public interface Output{

int MAX_CACHE_LINE=50;//接口定义的成员变量只能是常量 ，系统默认的都是public static final，不管你写不写；

void out（）；//接口定义的普通方法只能是public的抽象方法 系统默认的都是public abstract，不管你写不写

//定义默认方法，需要使用 default修饰

default void print(String ...msgs){

for(String msg:msgs){

System.out.println("msg");

}

//在接口中定义类方法，需要使用static修饰

static String  staticTest（）{

return "接口类方法"；

}

//通过包名和接口类名可以访问接口类的成员变量

}

}

2 接口的继承

接口支持多继承

interface interfaceA{

int PROP_A=5;

void testA();

}

interface interfaceB{

int PROP_B=6;

void testB();

}

interface interfaceC extends interfaceA,interfaceB{

int PROP_C=7;

void testC();

}

interfaceC.PROP_A;

interfaceC.PROP_B;

2 接口的使用

接口不能创建实例，但接口可以用于声明引用类型的变量。接口更像是一种规范

实现接口和继承父类理解 ：把接口的实现理解为一种特殊的继承，相当于实现类继承了一个彻底抽象类（相当于除了默认方法，其他方法都是抽象方法）

3 面向接口编程

 简单工厂模式

public interface Output{

int MAX_CACHE_LINE=50;//接口定义的成员变量只能是常量 ，系统默认的都是public static final，不管你写不写；

void out（）；//接口定义的普通方法只能是public的抽象方法 系统默认的都是public abstract，不管你写不写

//定义默认方法，需要使用 default修饰

default void print(String ...msgs){

for(String msg:msgs){

System.out.println("msg");

}

public class Computer{

private Output out;

public Computer (Output out){

this.out=out;

}

//定义一个获得模拟字符串的输入内容

public void keyIn(Stirng msg){

out.getData(msg);

}

//模拟一个打印方法

public void print(){

out.out();

}

}

public class OutputFactory{

public Output getOutput(){

return new Printer ;//重点在这个方法

}

public static void main(String []args){

OutputFactory of=new OutputFactory();

Computer c=new Computer(of.getOutput);

}

}

public class Printer implements Output{}//注意 return new Printer();该类要实现该接口

命令模式

public interface Command{

void process(int [] target);

}

public class ProcessArray{

public void process (int[]target,Command cmd){

cmd.process(target);

}

ProcessArray pa=new ProcessArray();

int[]target{3,4,5,6};

pa.process(target,new PrintCommand);

}

public class PrintCommand implements Command{

public void process(int [] target){

for(int tmp:target){

}

}

}