day09.抽象 多态 接口

  1. 课前回顾:
  2.   1.封装
  3.     this:代表当前对象,哪个对象调用this所在的方法,this就代表哪个对象
  4.          区分重名的成员变量和局部变量
  5.     无参构造:
  6.          new 对象
  7.          不写jvm默认给一个
  8.     有参构造:
  9.          new 对象
  10.          为属性赋值
  11.          如果写了有参构造,无参构造就没了,所以我们都手写上
  12.     标准的javabean:私有属性 无参构造 有参构造 get/set方法
  14.   2.继承:
  15.     关键字:extends
  16.     成员访问特点:
  17.       成员变量:看等号左边是谁先调用谁
  18.       成员方法:看new的是谁先调用谁,子类没有找父类
  19.     重写:
  20.       前提:有子父类继承关系
  21.       使用场景:功能的增强,更新
  22.     特点:
  23.       继承只支持单继承,不能多继承
  24.       继承支持多层继承
  25.       一个父类可以拥有多个子类
  26.   3.super和this
  27.     super:代表父类对象
  28.           调用父类的构造:super()->super必须在构造第一行
  29.           调用父类的成员变量:super.成员变量名
  30.           调用父类的成员方法:super.成员方法名
  31.     this:代表的当前对象
  32.           调用当前类的构造:this()->this也要在构造第一行,所以,不能和super一起使用
  33.           调用当前类的成员变量:this.成员变量
  34.           调用当前类的成员方法:this.成员方法
  35.   4.代码块:
  36.     构造代码块
  37.      {
  38.      代码
  39.      }
  40.      优先于构造方法执行,且每new一次,构造代码块就执行一次
  41.     静态代码块:
  42.     static{
  44.     }
  45.      优先于构造方法和构造代码块执行的,只执行一次
  47. 今日内容:
  48.    1.会定义抽象类,以及会利用子类去实现抽象方法
  49.    2.知道抽象类的特点
  50.    3.会在多态的前提下访问成员
  51.    4.知道多态的好处
  52.    5.会定义接口,在接口中定义抽象方法,成员变量,默认方法,静态方法
  53.    6.会定义实现类实现接口

第一章.抽象

day09[抽象_多态_接口] - 图1

1.抽象的介绍

  1. 1.抽象方法怎么形成:
  2.   当将所有类的共性方法抽取到父类中,发现方法无法做具体实现(因为每个子类对这个方法的实现不一样),所以此方法抽取出来之后就可以定义为"抽象方法"
  3. 2.抽象类怎么形成:
  4.   抽象方法所在类一定是抽象类
  6. 3.抽象类和抽象方法是一种代码设计理念
  7.   因为抽象方法抽取出来之后,可以作为一个标准,规定,凡是我的子类都必须拥有这个方法,且必须要去做具体实现
  9. 4.抽象类和抽象方法的特点
  10.    a.抽象方法所在的类一定是抽象类
  11.    b.抽象类中不一定非得有抽象方法
  12.       (还可以包含:私有属性,构造,普通的成员方法)
  13.    c.子类继承抽象父类,需要重写父类中的抽象方法
  14.    d.抽象类不能直接new对象,需要通过子类做具体实现
  1. 1.关键字:abstract->抽象
  2. 2.抽象类的定义:
  3.   public abstract class 类名{
  5.   }
  6. 3.抽象方法:
  7.   public abstract 返回值类型 方法名();
  8. 4.注意:
  9.   抽象方法必须要重写
  1. public abstract class Animal {
  2.   public abstract void eat();
  3. }
  1. public class Dog extends Animal{
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("狗啃骨头");
  5.     }
  6. }
  1. public class Cat extends Animal{
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("猫吃鱼");
  5.     }
  6. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //Animal animal = new Animal();抽象类不能直接new对象
  4.         Dog dog = new Dog();
  5.         dog.eat();
  7.         System.out.println("================");
  9.         Cat cat = new Cat();
  10.         cat.eat();
  11.     }
  12. }

2.抽象的注意事项

  1. 1.抽象类不能直接new对象的,只能创建其非抽象子类的对象。
  2. 2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员(属性)使用的。
  3. 3.抽象类中，可以有成员变量。
  4. 4.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
  5. 5.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
  1. public abstract class Animal {
  2.     private String name;
  3.     private String color;
  5.     public Animal() {
  6.     }
  8.     public Animal(String name, String color) {
  9.         this.name = name;
  10.         this.color = color;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     public String getColor() {
  22.         return color;
  23.     }
  25.     public void setColor(String color) {
  26.         this.color = color;
  27.     }
  29.     //定义抽象方法
  30.     public abstract void eat();
  31.     public abstract void drink();
  32. }
  1. public class Dog extends Animal{
  2.     public Dog() {
  3.     }
  5.     public Dog(String name, String color) {
  6.         super(name, color);
  7.     }
  9.     @Override
  10.     public void eat() {
  11.         System.out.println("狗啃骨头");
  12.     }
  14.     @Override
  15.     public void drink() {
  16.         System.out.println("狗喝水");
  17.     }
  18. }
  1. public abstract class Cat extends Animal{
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("猫吃鱼");
  5.     }
  6. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Dog dog = new Dog("二哈", "黑白");
  4.     }
  5. }

第二章.综合案例

  1. 某IT公司有多名员工，按照员工负责的工作不同，进行了部门的划分（研发部、维护部）。
  2. 研发部(Developer)根据所需研发的内容不同，又分为 JavaEE工程师 、Android工程师 ；
  3. 维护部(Maintainer)根据所需维护的内容不同，又分为 网络维护工程师 、硬件维护工程师 。
  5. 公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。
  7. 工作内容:
  9. - JavaEE工程师： 员工号为xxx的 xxx员工，正在研发淘宝网站
  10. - Android工程师：员工号为xxx的 xxx员工，正在研发淘宝手机客户端软件
  11. - 网络维护工程师：员工号为xxx的 xxx员工，正在检查网络是否畅通
  12. - 硬件维护工程师：员工号为xxx的 xxx员工，正在修复打印机
  14. 请根据描述，完成员工体系中所有类的定义，并指定类之间的继承关系。进行XX工程师类的对象创建，完成工作方法的调用。

day09[抽象_多态_接口] - 图2

方式1:利用set赋值

  1. //员工类
  2. public abstract class Employee {
  3.     private int id;
  4.     private String name;
  6.     public Employee() {
  7.     }
  9.     public Employee(int id, String name) {
  10.         this.id = id;
  11.         this.name = name;
  12.     }
  14.     public int getId() {
  15.         return id;
  16.     }
  18.     public void setId(int id) {
  19.         this.id = id;
  20.     }
  22.     public String getName() {
  23.         return name;
  24.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  30.     //抽象方法
  31.     public abstract void work();
  32. }
  1. //研发部
  2. public abstract class Developer extends Employee{
  3. }
  1. public class JavaEE extends Developer{
  2.     @Override
  3.     public void work() {
  4.         System.out.println("编号为:"+this.getId()+"的"+this.getName()+"员工正在搞网站");
  5.     }
  6. }
  1. public class Android extends Developer{
  2.     @Override
  3.     public void work() {
  4.         System.out.println("编号为:"+getId()+"的"+getName()+"员工正在搞APP");
  5.     }
  6. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         JavaEE javaEE = new JavaEE();
  4.         //为属性赋值
  5.         javaEE.setId(1);
  6.         javaEE.setName("柳岩");
  7.         javaEE.work();
  9.         System.out.println("===========");
  11.         Android android = new Android();
  12.         android.setId(2);
  13.         android.setName("杨幂");
  14.         android.work();
  15.     }
  16. }

方式2:利用构造赋值

  1. //员工类
  2. public abstract class Employee {
  3.     private int id;
  4.     private String name;
  6.     public Employee() {
  7.     }
  9.     public Employee(int id, String name) {
  10.         this.id = id;
  11.         this.name = name;
  12.     }
  14.     public int getId() {
  15.         return id;
  16.     }
  18.     public void setId(int id) {
  19.         this.id = id;
  20.     }
  22.     public String getName() {
  23.         return name;
  24.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  30.     //抽象方法
  31.     public abstract void work();
  32. }
  1. public abstract class Developer extends Employee{
  2.     public Developer() {
  3.     }
  5.     public Developer(int id, String name) {
  6.         super(id, name);
  7.     }
  8. }
  1. public class JavaEE extends Developer{
  2.     public JavaEE() {
  3.     }
  5.     public JavaEE(int id, String name) {
  6.         super(id,name);
  7.     }
  9.     @Override
  10.     public void work() {
  11.         System.out.println("编号为:"+this.getId()+"的"+this.getName()+"员工正在搞网站");
  12.     }
  13. }
  1. public class Android extends Developer{
  2.     public Android() {
  3.     }
  5.     public Android(int id, String name) {
  6.         super(id, name);
  7.     }
  9.     @Override
  10.     public void work() {
  11.         System.out.println("编号为:"+getId()+"的"+getName()+"员工正在搞APP");
  12.     }
  13. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //使用构造方法为属性赋值
  4.         JavaEE javaEE1 = new JavaEE(3, "金莲");
  5.         javaEE1.work();
  7.     }
  8. }

小结:

关键字:abstract

抽象方法: public abstract 返回值类型 方法名();

抽象类:public abstract class 类名{}

注意:

抽象方法所在的类一定是抽象类

抽象类不一定非得有抽象方法

抽象类中还可以有(私有属性,构造,普通的成员方法)

抽象类不能直接new对象

子类继承抽象父类之后,必须要重写抽象方法

第三章.多态

  1. 怎么学多态
  2. 1.会使用多态的形式创建对象
  3. 2.知道多态的好处

1.多态的介绍

  1. 1.面向对象三大特征:封装    继承    多态
  2. 2.前提:
  3.   a.必须有子父类继承关系或者接口实现关系
  4.   b.必须有方法的重写->没有方法重写多态没有意义(利用多态访问成员变量,没任何意义)
  5.   c.创建对象:父类引用指向子类对象
  6.             父类 对象名 = new 子类()
  7. 3.弊端
  8.   利用多态的形式new对象,不能直接调用子类特有方法

2.多态的基本使用

  1. 1.创建父类
  2. 2.创建子类继承父类
  3. 3.在子类中重写方法
  4. 4.利用多态形式创建对象:父类 对象名 = new 子类()
  5. 5.调用子类重写的方法
  1. public abstract class Animal {
  2.     public abstract void eat();
  3. }
  1. public class Dog extends Animal{
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("狗啃骨头");
  5.     }
  7.     //特有方法
  8.     public void lookDoor(){
  9.         System.out.println("狗会看门");
  10.     }
  11. }
  1. public class Cat extends Animal{
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("猫吃鱼");
  5.     }
  7.     //特有方法
  8.     public void catchMouse(){
  9.         System.out.println("猫会抓老鼠");
  10.     }
  11. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Animal animal = new Dog();
  4.         animal.eat();
  5.         //animal.lookDoor();多态形式不能调用子类特有功能
  7.         System.out.println("=============");
  9.         Animal animal1 = new Cat();
  10.         animal1.eat();
  11.     }
  12. }

3.多态的条件下成员的访问特点

3.1成员变量

  1. 看等号左边是谁,先调用谁->成员变量没有多态性
  1. public class Fu {
  2.     int num = 100;
  3. }
  1. public class Zi extends Fu{
  2.     int num = 10;
  3. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Zi zi = new Zi();
  4.         System.out.println(zi.num);
  6.         Fu fu = new Zi();
  7.         System.out.println(fu.num);
  8.     }
  9. }

3.2成员方法

  1. 看new的是谁先调用谁中的方法,子类没有,找父类->成员方法是有多态性的
  1. public class Fu {
  2.     int num = 100;
  4.     public void method(){
  5.         System.out.println("我是父类中的method方法");
  6.     }
  7. }
  1. public class Zi extends Fu{
  2.     int num = 10;
  4.     public void method(){
  5.         System.out.println("我是子类中的method方法");
  6.     }
  7. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Zi zi = new Zi();
  4.         System.out.println(zi.num);
  5.         zi.method();//调用重写的
  7.         Fu fu = new Zi();
  8.         System.out.println(fu.num);
  9.         fu.method();//调用重写的
  10.     }
  11. }

4.多态的好处(为什么学多态)

  1. 1.多态的好处不体现在new对象上,体现在方法参数传递上
  2. 2.不用多态和同多态有什么好处和弊端:
  3.   不用多态:
  4.     好处:既可以调用从父类继承过来的,还能调用重写的,还能调用自己特有的方法
  5.     弊端:在传参数的过程中扩展性很差
  7.   多态:
  8.     弊端:不能直接调用子类特有方法
  9.     好处:在传递参数的过程中扩展性强
  1. public abstract class Animal {
  2.     public abstract void eat();
  3. }
  1. public class Dog extends Animal {
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("狗啃骨头");
  5.     }
  7.     //特有方法
  8.     public void lookDoor(){
  9.         System.out.println("狗会看门");
  10.     }
  11. }
  1. public class Cat extends Animal {
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("猫吃鱼");
  5.     }
  7.     //特有方法
  8.     public void catchMouse(){
  9.         System.out.println("猫会抓老鼠");
  10.     }
  11. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //原始方式new对象
  4.         Dog dog = new Dog();
  5.         method(dog);
  7.         Cat cat = new Cat();
  8.         method(cat);
  9.     }
  11.     public static void method(Animal animal){//Animal animal = dog;  Animal animal = cat
  12.         animal.eat();
  13.     }
  14. }

5.多态中的转型

5.1向上转型

  1. 1.默认:  父类引用指向子类对象
  2.   父类类型 对象名 = new 子类对象 
  4.   好比:  doule b = 10;

5.2向下转型

  1. 1.如果想要调用子类特有方法,就需要向下转型
  3. 2.怎能转:
  4.    父类类型 对象名 = new 子类对象->向上转型
  6.    子类类型 对象名1 = (子类类型)对象名->向下转型
  8.    好比:
  9.       double b = 10;->将int转成了double
  10.       int i = (int)b;->将double强转成了int
  13.       Animal animal = new Dog();->向上转型
  14.       Dog dog = (Dog)animal;-->向下转型
  1. public abstract class Animal {
  2.     public abstract void eat();
  3. }
  1. public class Cat extends Animal {
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("猫吃鱼");
  5.     }
  7.     //特有方法
  8.     public void catchMouse(){
  9.         System.out.println("猫会抓老鼠");
  10.     }
  11. }
  1. public class Dog extends Animal {
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("狗啃骨头");
  5.     }
  7.     //特有方法
  8.     public void lookDoor(){
  9.         System.out.println("狗会看门");
  10.     }
  11. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Animal animal = new Dog();
  4.         animal.eat();
  6.         //向下转型
  7.         Dog dog = (Dog)animal;
  8.         dog.lookDoor();
  10.         System.out.println("=================");
  12.         Animal animal1 = new Cat();
  13.         animal1.eat();
  14.         //向下转型
  15.         Cat cat = (Cat) animal1;
  16.         cat.catchMouse();
  17.     }
  19. }

6.转型可能会出现的问题

  1. 1.向下转型时注意的问题:
  2.   如果等号左右两边类型不一致时:ClassCastException(类型转换异常)
  3. 2.如何去判断类型:
  4.   关键字:instanceof   -> 结果是一个boolean型
  5.   使用格式: 对象名 instanceof 具体类型
  7.           关键字前面的对象是否属于关键字后面的类型
  1. public abstract class Animal {
  2.     public abstract void eat();
  3. }
  1. public class Dog extends Animal {
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("狗啃骨头");
  5.     }
  7.     //特有方法
  8.     public void lookDoor(){
  9.         System.out.println("狗会看门");
  10.     }
  11. }
  1. public class Cat extends Animal {
  2.     @Override
  3.     public void eat() {
  4.         System.out.println("猫吃鱼");
  5.     }
  7.     //特有方法
  8.     public void catchMouse(){
  9.         System.out.println("猫会抓老鼠");
  10.     }
  11. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Dog dog = new Dog();
  4.         method(dog);
  6.         method(new Cat());
  7.     }
  9.     public static void method(Animal animal){
  10.         if (animal instanceof Dog){
  11.             animal.eat();
  12.             Dog dog = (Dog) animal;
  13.             dog.lookDoor();
  14.         }
  16.         if (animal instanceof Cat){
  17.             animal.eat();
  18.             //将代表dog的animal强转成Cat
  19.             Cat cat = (Cat)animal;
  20.             cat.catchMouse();
  21.         }
  22.     }
  23. }

小结:

1.前提:

  1. a.必须有子父类继承关系或者接口实现关系
  3. b.必须有方法的重写(多态没有方法的重写,多态没有意义)
  5. c.父类引用指向子类对象

2.成员访问特点:

  1.  成员变量:看等号左边是谁,先调用谁
  3.  成员方法:看new的是谁,先调用谁,子类没有找父类

3.多态的好处:

  1.  弊端:不能调用子类特有的方法
  3.  好处:当作为方法参数传递的时候,扩展性强

4.转型

  1. 向上转型:默认   父类引用指向子类对象

向下转型:强转,将父类类型强转会子类类型

5.转型容易出现的问题:ClassCastException(类型转换异常)

  1.  原因:等号左右两边的类型不一致
  3.  解决:做判断
  5.           对象名 instanceof 类型->可以判断类型

第四章.接口

1.接口的介绍

  1. 1.概述:标准,规则,引用数据类型
  2. 2.关键字:interface(接口)   implements(实现)
  3. 3.成员比较单一的
  4.   jdk7:
  5.     抽象方法:带abstract的方法   不写也有
  6.     成员变量:带static final的,表示最终的变量,所以值不能改变  不写static final也有
  7.   jdk8:
  8.     默认方法:public default 返回值类型 方法名(参数){}
  9.     静态方法:public static 返回值类型 方法名(参数){}
  10.   jdk9:
  11.     私有方法:private 返回值类型 方法名(参数){}

day09[抽象_多态_接口] - 图3

2.接口的定义以及使用

  1. 1.定义:
  2.   public interface 接口名{
  4.   }
  5. 2.定义实现类
  6.   public class 类名 implements 接口名{
  7.      重写接口中的抽象方法
  8.   }
  9. 3.注意:
  10.   a.定义接口之后需要实现类去实现它
  11.   b.实现类实现接口的时候,要重写接口中的抽象方法
  12.   c.接口不能new对象,只能通过new实现类对象调用重写的方法
  1. public interface USB {
  2.     //定义抽象方法
  3.     public abstract void open();
  4.     void close();
  5. }
  1. public class Mouse implements USB{
  2.     @Override
  3.     public void open() {
  4.         System.out.println("鼠标插进去打开了");
  5.     }
  7.     @Override
  8.     public void close() {
  9.         System.out.println("鼠标拔出来就关闭了");
  10.     }
  11. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         //USB usb = new USB();接口不能直接new对象
  4.         Mouse mouse = new Mouse();
  5.         mouse.open();
  6.         mouse.close();
  8.         System.out.println("=================");
  9.         //利用多态的形式去new
  10.         USB usb = new Mouse();
  11.         usb.open();
  12.         usb.close();
  13.     }
  14. }

3.接口中的成员

3.1抽象方法

  1. 1.定义:
  2.   public abstract 返回值类型 方法名(参数);
  3. 2.使用:
  4.   a.定义实现类实现接口
  5.   b.在实现类中重写抽象方法
  6.   c.new实现类对象,调用重写方法
  7. 3.注意:
  8.   如果在接口中定义一个没有方法体的方法,就是抽象方法
  9.   即使不写abstract,默认也有
  1. public interface USB {
  2.     //定义抽象方法
  3.     public abstract void open();
  4.     //没有写abstract,默认也有
  5.     void close();
  6. }
  1. public class KeyBoard implements USB{
  2.     @Override
  3.     public void open() {
  4.         System.out.println("键盘开启");
  5.     }
  7.     @Override
  8.     public void close() {
  9.         System.out.println("键盘关闭");
  10.     }
  11. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         KeyBoard keyBoard = new KeyBoard();
  4.         keyBoard.open();
  5.         keyBoard.close();
  7.         System.out.println("=================");
  9.         //多态形式
  10.         USB usb = new KeyBoard();
  11.         usb.open();
  12.         usb.close();
  13.     }
  14. }

3.2默认方法

  1. 1.定义:
  2.   public default 返回值类型 方法名(参数){
  3.       方法体
  4.       return 结果
  5.   }
  6. 2.使用:
  7.   a.定义实现类,实现接口
  8.   b.如果不对接口中的默认方法进行功能修改,就不用重写了
  9.     如果要对接口中的默认方法进行功能修改,就需要重写默认方法(不要带default)
  10.   c.创建实现类对象,调用默认方法或者重写的方法
  1. public interface USB {
  2.     //默认方法
  3.     public default void start(){
  4.         System.out.println("USB打开了");
  5.     }
  6. }
  1. public class Mouse implements USB{
  2.     @Override
  3.     public void start(){
  4.         System.out.println("鼠标打开了");
  5.     }
  6. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Mouse mouse = new Mouse();
  4.         mouse.start();
  5.     }
  6. }

3.3静态方法

  1. 1.定义格式:
  2.   public static 返回值类型 方法名(参数){
  3.       方法体
  4.       return 结果
  5.   }
  6. 2.使用:
  7.   接口名直接调用
  1. public interface USB {
  2.     //静态方法
  3.     public static void start(){
  4.         System.out.println("usb开启了");
  5.     }
  6. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.        USB.start();
  4.     }
  5. }

在类中定义的静态方法,也不能被重写

3.4成员变量

  1. 1.定义格式:
  2.   public static final 数据类型 变量名 = 值
  3.   即使不写public static final默认也有
  4. 2.使用:
  5.   接口名直接调用
  6. 3.注意:
  7.   a.接口中的成员变量即使不写public static final默认也有
  8.   b.接口中的成员变量需要手动赋值
  9.   c.接口中的成员变量不能被二次赋值
  10.   d.被static final修饰的变量名字一般都要大写(习惯上的写法)
  1. public interface Interface {
  2.     public static final int NUM = 100;
  3.     //num = 200;被final修饰的成员变量不能被二次赋值
  4.     int I = 10;
  5. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         System.out.println(Interface.NUM);
  4.     }
  5. }

4.接口的特点

  1. 1.接口可以多继承
  2.   public interface InterfaceC extends InterfaceA,InterfaceB{
  3.   }
  4. 2.一个实现类可以同时实现一个或者多个接口->需要重写接口中所有的抽象方法
  5.   public class InterfaceImpl implements InterfaceA,InterfaceB{
  6.   }
  7. 3.一个实现类可以继承一个父类的同时实现一个或者多个接口->需要重写父类中和接口中所有的抽象方法
  8.   public class Zi extends Fu implements InterfaceA,InterfaceB{
  9.   }

如果抽象方法有重名的，只需要重写一次

如果默认方法有重名的，必须重写一次

5.接口和抽象类的区别

  1. 相同点:
  3.      都位于继承的顶端,用于被其他类实现或继承;
  5.      都不能直接实例化对象;
  7.      都包含抽象方法,其子类都必须重写这些抽象方法;
  9. 不同点:
  10.      抽象类:一般作为父类使用,可以有成员变量 构造方法 成员方法等
  11.      接口:成员单一,一般抽取接口,抽取的都是方法,是功能的大集合
  12.      类不能多继承,但是接口可以

6.综合练习

  1. 定义笔记本类，具备开机，关机和使用USB设备的功能。具体是什么USB设备，笔记本并不关心，只要符合USB规格的设备都可以。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，不然鼠标和键盘的生产出来无法使用;
  2. 进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘
  4. - USB接口，包含开启功能、关闭功能
  5. - 笔记本类，包含运行功能、关机功能、使用USB设备功能
  6. - 鼠标类，要符合USB
  7. - 键盘类，要符合USB接口

day09[抽象_多态_接口] - 图4

  1. public interface USB {
  2.     //开启
  3.     void open();
  4.     //关闭
  5.     void close();
  6. }
  1. public class Mouse implements USB{
  2.     @Override
  3.     public void open() {
  4.         System.out.println("鼠标开启");
  5.     }
  7.     @Override
  8.     public void close() {
  9.         System.out.println("鼠标关闭");
  10.     }
  11. }
  1. public class KeyBoard implements USB{
  2.     @Override
  3.     public void open() {
  4.         System.out.println("键盘开启");
  5.     }
  7.     @Override
  8.     public void close() {
  9.         System.out.println("键盘关闭");
  10.     }
  11. }
  1. public class NoteBook {
  2.     //开机
  3.     public void start(){
  4.         System.out.println("开机了,来啊,使用我呀");
  5.     }
  7.     //使用USB方法
  8.     public void useUsb(USB usb){
  9.         usb.open();
  10.         usb.close();
  11.     }
  13.     //关机
  14.     public void stop(){
  15.         System.out.println("关机了,你不要来了");
  16.     }
  17. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //创建鼠标和键盘对象
  4.         Mouse mouse = new Mouse();
  5.         KeyBoard keyBoard = new KeyBoard();
  7.         //创建笔记本类对象
  8.         NoteBook noteBook = new NoteBook();
  9.         noteBook.start();
  10.         noteBook.useUsb(mouse);
  11.         noteBook.useUsb(keyBoard);
  12.         noteBook.stop();
  13.     }
  14. }

day09[抽象_多态_接口] - 图5

7.综合练习升级版

  1. public interface USB {
  2.     //开启
  3.     void open();
  4.     //关闭
  5.     void close();
  6. }
  1. public class Mouse implements USB{
  2.     @Override
  3.     public void open() {
  4.         System.out.println("鼠标开启");
  5.     }
  7.     @Override
  8.     public void close() {
  9.         System.out.println("鼠标关闭");
  10.     }
  12.     //特有方法
  13.     public void click(){
  14.         System.out.println("我可以单击");
  15.     }
  16. }
  1. public class KeyBoard implements USB{
  2.     @Override
  3.     public void open() {
  4.         System.out.println("键盘开启");
  5.     }
  7.     @Override
  8.     public void close() {
  9.         System.out.println("键盘关闭");
  10.     }
  11.     //特有方法
  12.     public void input(){
  13.         System.out.println("键盘输入");
  14.     }
  15. }
  1. public class NoteBook {
  2.     //开机
  3.     public void start(){
  4.         System.out.println("开机了,来啊,使用我呀");
  5.     }
  7.     //使用USB方法
  8.     public void useUsb(USB usb){
  9.         if (usb  instanceof Mouse){
  10.             usb.open();
  11.             usb.close();
  12.             //向下转型
  13.             Mouse mouse = (Mouse)usb;
  14.             mouse.click();
  15.         }
  17.         if (usb  instanceof KeyBoard){
  18.             usb.open();
  19.             usb.close();
  20.             //向下转型
  21.             KeyBoard keyBoard = (KeyBoard)usb;
  22.             keyBoard.input();
  23.         }
  24.     }
  26.     //关机
  27.     public void stop(){
  28.         System.out.println("关机了,你不要来了");
  29.     }
  30. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //创建鼠标和键盘对象
  4.         Mouse mouse = new Mouse();
  5.         KeyBoard keyBoard = new KeyBoard();
  7.         //创建笔记本类对象
  8.         NoteBook noteBook = new NoteBook();
  9.         noteBook.start();
  10.         noteBook.useUsb(mouse);
  11.         noteBook.useUsb(keyBoard);
  12.         noteBook.stop();
  13.     }
  14. }

第五章.权限修饰符

5.1 概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

  • public：公共的。
  • protected：受保护的
  • default：默认的,不写任何权限修饰符,那么整个权限就是默认权限
  • private：私有的

5.2 不同权限的访问能力

public protected default（空的） private
同一类中 √ √ √ √
同一包中不同类(子类与无关类) √ √ √ x
不同包的子类 √ √
不同包中的无关类 √

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

  • 成员变量使用private ，隐藏细节。
  • 构造方法使用public ，方便创建对象。
  • 成员方法使用public ，方便调用方法。

第六章.final关键字

  1. 1.概述:最终的
  2. 2.用法:
  3.   修饰类
  4.   修饰方法
  5.   修饰成员变量
  6.   修饰局部变量
  7.   修饰对象

1.final修饰类

  1. 1.格式:
  2.   public final class 类名{
  4.   }
  5. 2.特点:
  6.   被final修饰的类不能被继承
  1. public final class Animal {
  2.     public void eat(){
  3.         System.out.println("动物要吃饭");
  4.     }
  5. }
  7. public class Dog /*extends Animal*/{//被final修饰的类不能被继承
  8. }

2.final修饰方法

  1. 1.格式:
  2.   public final 返回值类型 方法名(参数){
  3.     方法体
  4.     return 结果
  5.   }
  7. 2.特点:
  8.   被final修饰的方法不能被重写
  1. public abstract class Animal {
  2.     public final void eat(){
  3.         System.out.println("动物要吃饭");
  4.     }
  6.     //public abstract final void drink();  abstract和final冲突
  7. }
  9. public class Dog extends Animal{
  11.     //被final修饰的方法不能被重写
  12.    /* public void eat(){
  13.         System.out.println("动物要吃饭");
  14.     }*/
  15. }