Java基础知识回顾复习（抽象类，接口）

抽象类：

• 拥有抽象方法的类就是抽象类。

• 抽象方法：是只有方法签名没有方法体，必须用abstract修饰。

• 抽象类本身也要用abstract修饰的，作用是让子类继承，子类一定要重写抽象方法。

• 模板思想，设计模板模式。

接口：

• 更加彻底的抽象，接口中全部是抽象方法和常量（JDK1.8之后）
• 接口体现的是规范思想，实现接口的类必须重写完接口的全部抽象方法，否这这个类必须是抽象类
• JDK1.8之后的接口新增了三个方法。接口不再纯洁

1.1抽象类概念

1.1.1 什么是抽象类？

父类知道子类的一定要完成某个功能，但是每个子类完成的情况是不一样的，子类以后也只会用自己重写的功能，那么父类的该功能就可以定义成抽象方法。

抽象类定义格式：

abstract class 类名字 { 
  
}



public abstract class Animal {
    public abstract void run()；
}

1.1.2什么是抽象方法？

没有方法体，只有方法签名，必须用abstract修饰，拥有抽象方法的类必须定义成抽象类。

抽象方法定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；


public abstract void run()；

 代码演示

// 父类,抽象类
abstract class Employee {
	private String id;
	private String name;
	private double salary;
	
	public Employee() {
	}
	
	public Employee(String id, String name, double salary) {
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	// 抽象方法
	// 抽象方法必须要放在抽象类中
	abstract public void work();
}

// 定义一个子类继承抽象类
class Manager extends Employee {
	public Manager() {
	}
	public Manager(String id, String name, double salary) {
		super(id, name, salary);
	}
	// 2.重写父类的抽象方法
	@Override
	public void work() {
		System.out.println("管理其他人");
	}
}

// 定义一个子类继承抽象类
class Cook extends Employee {
	public Cook() {
	}
	public Cook(String id, String name, double salary) {
		super(id, name, salary);
	}
	@Override
	public void work() {
		System.out.println("厨师炒菜多加点盐...");
	}
}

// 测试类
public class Demo10 {
	public static void main(String[] args) {
		// 创建抽象类,抽象类不能创建对象
		// 假设抽象类让我们创建对象,里面的抽象方法没有方法体,无法执行.所以不让我们创建对象
//		Employee e = new Employee();
//		e.work();
		
		// 3.创建子类
		Manager m = new Manager();
		m.work();
		
		Cook c = new Cook("ap002", "库克", 1);
		c.work();
	}
}

1.2抽象类的特征

抽象类的特征总结起来可以说是 有得有失

有得：抽象类得到了拥有抽象方法的能力。

有失：抽象类失去了创建对象的能力。

1.3抽象类的注意事项

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

   理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2. 抽象类中，可以有构造器，是供子类创建对象时，初始化父类成员使用的。

   理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

   理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则子类也必须定义成抽象类，编译无法通过而报错。

   理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

5. 抽象类存在的意义是为了被子类继承，抽象类体现的是模板思想。

   理解：抽象类中已经实现的是模板中确定的成员，抽象类不确定如何实现的定义成抽象方法，交给具体的子类去实现。

1.4抽象类存在的意义

抽象类存在的意义是为了被子类继承，否则抽象类将毫无意义，抽象类体现的是模板思想，模板是通用的东西抽象类中已经是具体的实现（抽象类中可以有成员变量和实现方法），而模板中不能决定的东西定义成抽象方法，让使用模板（继承抽象类的类）的类去重写抽象方法实现需求，这是典型的模板思想。

1.5设计模式：模板设置

/*
          作文模板:
                  标题固定：《我的爸爸》
                  第一段固定：请介绍一下你的爸爸，说说你的爸爸有多好，有多牛逼
                  正文部分(自由发挥)： 抽象出来。
                  结尾固定： 总结，我的爸爸多棒，有这样的爸爸太好了，下辈子还要做他儿子。
*/



public class AbstractDemo {

    public static void main(String[] args) {
        Student yhb = new Student();

        yhb.write();
    }
}

class Student extends Template{
    @Override
    public String writeMain() {
        return "\t\t\t 我的爸爸很牛逼，他是。。。。。。";
    }
}


//1。设计一个模板类
abstract class Template{
    private String title = "\t\t\t\t\t\t《我的爸爸》";
    private String one = "\t\t 请介绍一下你的爸爸，说说你的爸爸有多好，有多牛逼";
    private String last = "\t\t总结，我的爸爸多棒，有这样的爸爸太好了，下辈子还要做他儿子。";

    //2.写作文的功能！
    public void write(){
        System.out.println(title);
        System.out.println(one);
        //3.写正文部分：正文部分不能确定，交给使用模板的子类来写！
        System.out.println(writeMain());
        System.out.println(last);

        //4.定义抽象方法
    }

    public abstract String writeMain();

}

运行效果：

 2.1接口概念

接口是更加彻底的抽象，接口中全部是抽象方法。（JDK8之前），接口同样是不能创建对象的。

 2.1.1：接口定义格式

//接口的定义格式：
修饰符 interface 接口名称{
    // 抽象方法
}

// 修饰符：public|缺省
// 接口的声明：interface
// 接口名称：首字母大写，满足“驼峰模式”

2.1.2：抽象方法和常量

抽象方法：

        注意：接口中的抽象方法默认会自动加上public abstract修饰程序员无需自己手写！！ ​ 按照规范：以后接口中的抽象方法建议不要写上public abstract。因为没有必要啊，默认会加上。

常量：

        在接口中定义的成员变量默认会加上： public static final修饰。也就是说在接口中定义的成员变量实际上是一个常量。这里是使用public static final修饰后，变量值就不可被修改，并且是静态化的变量可以直接用接口名访问，所以也叫常量。常量必须要给初始值。常量命名规范建议字母全部大写，多个单词用下划线连接。

代码实例

public interface InterF {
    // 抽象方法！
    //    public abstract void run();
    void run();

    //    public abstract String getName();
    String getName();

    //    public abstract int add(int a , int b);
    int add(int a , int b);


    // 它的最终写法是：
    // public static final int AGE = 12 ;
    // public static final String SCHOOL_NAME = "我是一个秃头程序员";
    int AGE  = 12; //常量
    String SCHOOL_NAME = "我是一个秃头程序员";

}

2.2.1接口的实现

概述：

        类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

格式：

/**接口的实现：
    在Java中接口是被实现的，实现接口的类称为实现类。
    实现类的格式:*/
[修饰符] class 类名 implements 接口1,接口2,接口3...{


}

2.3.1类实现接口的要求和意义

1. 必须重写实现的全部接口中所有抽象方法。

2. 如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。

3. 意义：接口体现的是一种规范，接口对实现类是一种强制性的约束，要么全部完成接口申明的功能，要么自己也定义成抽象类。这正是一种强制性的规范。

2.4.1类与接口基本实现案例

public class InterfaceDemo {
    public static void main(String[] args) {
        //创建乒乓球运动员对象
        PingPangMan zjk = new PingPangMan("张继科");
        zjk.run();
        zjk.jump();
        System.out.println(zjk.competition("全球乒乓球大赛"));
    }

}


//类实现接口
class PingPangMan implements SportMan{

    private String name;
    public PingPangMan(String name) {
        this.name = name;
    }

    //重写方法
    @Override
    public void run() {
        System.out.println(name+"乒乓球跑步");
    }
    //重写方法
    @Override
    public void jump() {
        System.out.println(name+"打篮球");
    }
    //重写方法
    @Override
    public String competition(String project) {
        return name + "参加" + project + "获得金牌";
    }
}


//定义一个接口
interface SportMan {
    void run();
    void jump();
    String competition(String project);
}

2.5JDK1.8之后的接口新增方法

从JDK 8开始之后，接口不再纯洁了，接口中不再只是抽象方法，接口还可以有默认方法（也就是实例方法），和静态方法了，还包含了私有实例方法和私有静态方法

2.5.1含有默认方法和静态方法

默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。

静态方法：使用 static 修饰，供接口直接调用。

代码如下：

public interface InterFaceName {
    public default void method() {
        // 执行语句
    }
    public static void method2() {
        // 执行语句    
    }
}

2.5.2含有私有方法和私有静态方法

私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。

代码如下：

public interface InterFaceName {
    private void method() {
        // 执行语句
    }
}

2.5.3 新增方法的使用

默认方法和静态方法以及私有方法和私有静态方法，遵循面向对象的继承关系使用原则，实现类依然可以访问接口的非私有方法，对于接口中的非私有静态方法，可以直接通过接口名进行访问。

重写默认方法注意（了解）:

• 子接口重写默认方法时，default关键字可以保留。

• 实现类重写默认方法时，default关键字不可以保留。

2.5.4优先级的问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

interface A {
    public default void methodA(){
        System.out.println("AAAAAAAAAAAA");
    }
}

 定义父类：

class D {
    public void methodA(){
        System.out.println("DDDDDDDDDDDD");
    }
}

定义子类：

class C extends D implements A {
  	// 未重写methodA方法
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        C c = new C();
        c.methodA(); 
    }
}
输出结果:
DDDDDDDDDDDD

总结：

• 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。

• 接口中的方法全是抽象方法，默认会自动加上public abstract修饰

• JDK 8开始，接口不再纯洁，支持静态方法，默认方法，私有方法。

• 接口中，没有构造器，不能创建对象。

• 类与接口是多实现的

• 接口与接口是多继承的

• 接口体现的规范。