就业阶段一：JavaSE学习_day03

多态

多态的实现（掌握）

• 多态的概念

  • 同一个对象，在不同时刻表现出来的不同形态。
  • 举例：狗🐕

  我们可以说狗是狗：狗类 dog = new 狗类();
  我们也可以说狗是动物：动物 dog = new 狗();
  这里的狗在不同的时刻表现出来了不同的形态，这就是多态
  

• 多态的前提和体现

有继承/实现关系

有方法重写

有父类引用指向子类对象

• 代码演示

package com.itheima.day03.domain;/*** @Author: ✎﹏ Sunflower丶* @Specification: 动物类*/
public class Animal {public void eat(){System.out.println("动物吃饭");}
}

package com.itheima.day03.domain;/*** @Author: ✎﹏ Sunflower丶* @Specification: 狗类*/
public class Dog extends Animal {@Overridepublic void eat() {System.out.println("小余啃骨头");}public void watchHome() {System.out.println("狗看家");}
}

package com.itheima.day03.test;import com.itheima.day03.domain.Animal;
import com.itheima.day03.domain.Dog;/*** @Author: ✎﹏ Sunflower丶* @Specification: 测试类*/
public class Test {/*多态的前提:1. 要有(继承 \ 实现)关系2. 要有方法重写3. 要有父类引用, 指向子类对象*/public static void main(String[] args) {//当前事物，是一只狗Dog dog = new Dog();//这是一只动物Animal animal = new Dog();animal.eat();}
}

多态中成员访问特点（记忆）

• 成员访问特点

  • 构造方法

    ​ 同继承一样，子类会通过super访问父类的构造方法

  • 成员变量

    ​ 编译看左边，执行看左边

  • 成员方法

    ​ 编译看左边，执行看右边

• 代码演示

//父类
public class Fu {int num = 10;public void method(){System.out.println("Fu.. method");}
}

//子类
public class Zi extends Fu {int num = 20;public void method(){System.out.println("Zi.. method");}
}

public class Test2 {/*多态的成员访问特点:成员变量: 编译看左边 (父类), 运行看左边 (父类)成员方法: 编译看左边 (父类), 运行看右边 (子类)*/public static void main(String[] args) {Fu f = new Zi();System.out.println(f.num);f.method();}
}

为什么成员变量与成员方法的访问结果不一样？

因为成员方法有重写，而成员变量没有

多态的好处和弊端（记忆）

• 好处

  ​ 提高程序的扩展性

  具体体现：定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作

• 弊端

  ​ 不能使用子类的特有功能(成员)

多态中的转型（应用）

转型	格式	解释
向上转型	父类引用 对象名 = new 子类型();	父类引用指向子类对象
向下转型	子类型 对象名 = (子类型)父类引用;	父类引用转向子类对象

• 代码演示

package com.itheima.day03.domain;/*** @Author: ✎﹏ Sunflower丶* @Specification: 猫类*/
public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}public void catchMouse() {System.out.println("猫抓老鼠");}
}

package com.itheima.day03.test;import com.itheima.day03.domain.Animal;
import com.itheima.day03.domain.Dog;/*** @Author: ✎﹏ Sunflower丶* @Specification: 测试类*/
public class Test {public static void main(String[] args) {//向上转型 : 父类引用指向子类对象Animal a = new Cat();a.eat();    //输出猫吃鱼// 多态的弊端: 不能调用子类特有的成员// a.catchMouse();// 2. 向下转型 : 从父类类型, 转换回子类类型Cat c = (Cat) a;a.catchMouse();//多态的好处：提高程序的扩展性//可以接收一切动物子类。Dog d = new Dog();useAnimal(d);useAnimal(a);useAnimal(c);}public static void useAnimal(Animal a){a.eat();}
}

多态中转型存在的风险和解决方案 (应用)

• 风险

  如果被转的引用类型变量,对应的实际类型和目标类型不是同一种类型,那么在转换的时候就会出现ClassCastException

• 关键字instanceof

• 使用格式：

  变量名 instanceof 类型

  通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结果

• 代码演示

  package com.itheima.day03.test;import com.itheima.day03.domain.Animal;
  import com.itheima.day03.domain.Dog;/*** @Author: ✎﹏ Sunflower丶* @Specification: 测试类*/
  public class Test {public static void main(String[] args) {useAnimal(new Dog());useAnimal(new Cat());}public static void useAnimal(Animal a){  //Animal a = new Dog();a.eat();//a.catchMouse()		ClassCastException  类型转换异常// 判断a变量记录的类型, 是否是Dogif(a instanceof Dog) {Dog dog = (Dog) a;dog.watchHome();}else if(a instanceof Cat) {Cat c = (Cat) a;c.catchMouse();}}
  }

接口

接口的概述（理解）

• 当一个类中所有的方法都是抽象方法，我们就将其定义为接口

• 接口也是一种引用数据类型，它比抽象类还要抽象。

  接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。

• Java中接口存在的两个意义

  • 规则的定义，用来定义规范
  • 程序的扩展性，用来做功能的拓展

接口的定义和特点

• 接口用关键字interface来定义
• 接口不能实例化
• 接口与类之间的实现关系，通过implements关键字表示
• 接口的子类(实现类)
  • 要么重写接口中的所有抽象方法
  • 要么是抽象类（不建议）
• 接口的定义格式

public interface 接口名{}

• 类实现接口的格式

  • 普通类的实现

  public class 类名 implements 接口名 {}

  • 抽象类的实现

  public abstract class 类名 {} implements 接口名 {}

• 范例：

public interface InterA {public abstract void add();void del();
}

public interface InterB {void upd();
}

public abstract class Demo implements InterA{
}

public class InterImpl implements InterA,InterB {@Overridepublic void add() {}@Overridepublic void del() {}@Overridepublic void upd() {}
}

注意：接口是可以多实现的

接口中的成员特点

成员变量

• 常量
• 系统默认修饰：public static final

构造方法

• 没有

成员方法

• 只能是抽象方法
• 系统默认修饰：public abstract

类和接口的关系（记忆）

• 类与类的关系

  ​ 继承关系，只能单继承，但是可以多层继承

• 类与接口的关系

  ​ 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

• 接口与接口的关系

  ​ 继承关系，可以单继承，也可以多继承

接口组成更新

接口组成及更新概述【理解】

接口的组成

• 常量

  public static final

• 抽象方法

  public abstract

• 默认方法(Java 8)

• 静态方法(Java 8)

• 私有方法(Java 9)

更新

• JDK8版本后

  1. 允许在接口中定义非抽象方法，但是需要使用关键字default修饰，这些方法解释默认方法。

     注意：定义方法上的修饰符中的默认修饰符是以不写来表示，与default无关。

  2. 接口中允许定义static静态方法

• JDK9版本后

  • 接口中允许定义private私有方法

接口中默认方法【应用】

• 定义格式：

  public default 返回值类型 方法名(参数列表){ }

• 范例：

  public default void show() {}
  

• 作用

  解决接口升级的问题

• 注意事项：

  • 默认方法不是抽象方法，所有不强制被重写，但可以被重写，重写的时候去掉default关键字

  • public可以省略，default不能省略
  • 如果实现了多个接口，多个接口中存在相同的方法声明，子类就必须对该方法进行重写

接口中静态方法【应用】

• 定义格式：

  public static 返回值类型 方法名(参数列表){ }

• 范例：

  public static void show() {}
  

• 注意事项：

  • 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
  • public可以省略，static不能省略

接口中私有方法【应用】

• 私有方法产生原因

  Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

• 定义格式

  • 格式1：

    private 返回值类型 方法名(参数列表){ }

  • 范例1：

    private void show() {}
    

  • 格式2

    private static 返回值类型 方法名(参数列表) { }

  • 范例2

    private static void show() { }
    

• 注意事项

  • 默认方法可以调用私有的静态方法和非静态方法
  • 静态方法只能调用私有的静态方法

接口的使用思路【理解】

• 如果发现一个类中所有的方法都是抽象方法，那么就可以将该类，改进为一个接口
• 涉及到了接口大面积更新方法，而不想去修改每一个实现类，就可以将更新的方法，定义为带有方法体的默认方法
• 希望默认方法调用的更加简洁，可以考虑设计为static静态方法。(需要去掉default关键字)
• 默认方法中出现了重复代码，可以考虑抽取出一个私有方法。(需要去掉default关键字)

如果父类和接口中出现了相同的方法声明，但代码逻辑不一样，运行方法的时候，会优先使用父类的代码逻辑