面向对象进阶-CSDN博客

本文链接：https://blog.csdn.net/m0_64500113/article/details/133690922

面向对象进阶

static

static: 表示静态，是 Java 中的一个修饰符，可以修饰成员方法，成员变量

静态的，意味着可以共享

static 修饰成员变量

被 static 修饰的成员变量，叫做静态变量

特点：

被该类所有对象共享
跟对象无关，随着类的加载而加载，优先于对象存在

调用方式：

类名调用( 推荐 )
对象名调用

静态变量内存图

静态变量是随着类的加载而加载的，优先于对象出现的

在这里插入图片描述

static 修饰成员方法

被 static 修饰的成员方法，叫做静态方法

特点：

多用在测试类和工具类中
Javabean类中很少会用

调用方式：

类名调用( 推荐 )
对象名调用

工具类

帮助我们做一些事情的，但是不描述任何事情的类，叫做工具类

工具类书写规则：

类名见名知意
私有化构造方法
```
public class ArrUtil{
    //私有构造方法
    private ArrUtil(){}
}
```
构造方法一旦私有，在外界就无法创建这个类的对象。

由于测试类不描述任何事物，所以创建其对象也毫无意义。

方法定义为静态

public class ArrUtil{
    //私有构造方法
    private ArrUtil(){}
    
    //方法定义为静态
    public static int getMax(...){...}
    public static int getMin(...){...}
    public static int getSum(...){...}
    public static int getAvg(...){...}
}

工具类中的方法在测试类调用格式：

工具类类名.工具类中的方法

练习：定义数组工具类

需求：在实际开发中，经常会遇到一些数组使用的工具类。

请按照如下要求编写一个数组的工具类：ArrayUtil

提供一个工具类方法printArr , 用于返回整数数组的内容。

返回的字符串格式如：[10,20,50,34,100] （只考虑整数数组，且只考虑一维数组）
提供这样一个工具方法 getAerage ,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组）
定义一个测试类TestDemo，调用该工具类的工具方法，并返回结果。

package Just.a02staticdemo2;

public class ArrayUtil {
    //私有化构造方法
    //目的：不让外界创建他的对象
    private ArrayUtil(){}

    //定义printArr，用于返回整数数组的内容
    public static String printArr(int[] arr){
        //定义一个 StringBuilder 类的对象，用来拼接数组
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        //for 循环遍历数组
        for (int i = 0; i < arr.length; i++) {
            //i 索引  arr[i] 数组元素
            if(i == arr.length - 1){
                sb.append(arr[i]);
            }else{
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        //把 StringBuilder 类型转换成 String 类型并返回
        return sb.toString();
    }

    //定义getAerage函数，用于返回平均值
    public static double getAerage(double[] arr){
        //定义变量，用来获取数组元素的总和
        double sum = 0;
        //for循环遍历数组
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        //定义变量，用来接收平均值
        double average = sum/arr.length;
        //返回平均值
        return average;
    }
}
===========================================================================================
package Just.a02staticdemo2;

public class TestDemo {
    public static void main(String[] args) {
        //测试工具类中的两个方法是否正确
        int[] arr1 = {1,2,3,4,5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);
        
        double[] arr2 = {1.5,3.7,4.9,5.8,6.6};
        double avg = ArrayUtil.getAerage(arr2);
        System.out.println(avg);
    }
}
============================================================================================
运行结果：
[1,2,3,4,5]
4.5

练习：定义学生工具类

需求：定义一个集合，用于存储3个学生对象。

学生类的属性为：name 、age、gender

定义一个工具类，用于获取集合中最大学生的年龄

package Just.a03staticdemo3;

public class Student {
    //定义私有化成员变量 姓名、年龄、性别
    private String name;
    private int age;
    private String gender;

    //无参构造函数
    public Student() {
    }

    //有参构造函数
    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    
     //获取
    public String getName() {
        return name;
    }
    
      //设置
    public void setName(String name) {
        this.name = name;
    }
    
     //获取
    public int getAge() {
        return age;
    }

    //设置
    public void setAge(int age) {
        this.age = age;
    }
    
     //获取
    public String getGender() {
        return gender;
    }
    
    //设置
    public void setGender(String gender) {
        this.gender = gender;
    }
}
=======================================================================================================
package Just.a03staticdemo3;

import java.util.ArrayList;

public class StudentTest {
    public static void main(String[] args) {
        //定义集合用来存储3个学生对象
        ArrayList<Student> list = new ArrayList<>();

        //创建三个学生对象
        Student stu1 = new Student("鑫鑫",21,"女");
        Student stu2 = new Student("肉墩",22,"女");
        Student stu3 = new Student("几坨",23,"男");

        //把创建的学生对象添加到集合中
        list.add(stu1);
        list.add(stu2);
        list.add(stu3);

        //调用工具类中的函数，用来返回集合中最大学生的年龄
        int maxAge = StudentUtil.getMaxAge(list);
        System.out.println("输出集合中最大学生的年龄：");
        System.out.println(maxAge);
    }
}
=============================================================================================================
package Just.a03staticdemo3;

import java.util.ArrayList;

public class StudentUtil {
    //定义私有化构造函数
    private StudentUtil(){}

    //定义方法，获取集合中最大学生的年龄
    public static int getMaxAge(ArrayList<Student> list){
        //定义变量，用来记录学生中的最大年龄
        int maxAge = list.get(0).getAge();
        //for循环遍历集合中的对象及对象的年龄
        for (int i = 0; i < list.size(); i++) {
            //获取集合中的对象
            Student stu = list.get(i);
            //获取对象的年龄
            int age = stu.getAge();
            //把学生中最大学生的年龄赋值给 maxAge
            if(maxAge < age){
                maxAge = age;
            }
        }
        return maxAge;
    }

}
=======================================================================================================
运行结果：
输出集合中最大学生的年龄：
23

static 的注意事项

static 的注意事项：

静态方法只能访问静态变量和静态方法
非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
静态方法中没有this关键字

静态：随着类的加载而加载

非静态：跟对象有关
在这里插入图片描述

从新认识main方法

在这里插入图片描述

public: 被 JVM 调用，访问权限足够大
static: 被 JVM 调用，不用创建对象，直接类名访问

因为 main 方法是静态的，所以测试类中其他方法也需要是静态的
void: 被 JVM 调用，不需要给 JVM 返回值
main: 一个通用的名称，虽然不是关键字，但是被 JVM 识别
String[] args: 以前用于接收键盘录入数据的，现在没用

继承

在这里插入图片描述

继承概述

继承定义

继承是面向对象三大特征之一，可以让类跟子类之间产生子父的关系。

继承的格式

Java 中提供一个关键字 extends ，用这个关键字，我们可以让一个类和另一个类建立起继承关系。

public class Student extends Person { }
Student 称为子类（派生类），Person 称为父类（基类或超类）。

使用继承的好处：

可以把多个子类中重复的代码抽取到父类中提高代码的复用性。
子类可以得到父类的属性和行为并进行使用
子类可以在父类的基础上，增加其他功能，使子类更强大。

什么时候用继承？

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码。

继承的特点

Java 只支持单继承，不支持多继承，但支持多层继承。

单继承：一个子类只能继承一个父类

不支持多继承：子类不能同时继承多个父类

多层继承：子类 A 继承父类 B ,父类 B 可以继承父类 C

每一个类都直接或间接的继承于 Object

注意：子类只能访问父类中非私有的成员

继承体系的设计

设计技巧

画图法：从下往上画

下面：子类

上面：父类

需要把子类中的共性内容抽取到父类中

核心：

1、共性内容抽取

2、子类是父类中的一种

书写代码：

从上往下
在这里插入图片描述

练习：继承的练习

（自己设计一个继承体系）

现在有四种动物：布偶猫、中国狸花猫、哈士奇、泰迪

暂时不考虑属性，只要考虑行为。

请按照继承的思想特点进行继承体系的设计。

四种动物分别有以下的行为：

布偶猫：吃法、喝水、抓老鼠
中国狸花猫：吃饭、喝水、抓老鼠
哈士奇：吃饭、喝水、看家、拆家
泰迪：吃饭、喝水、看家、蹭一蹭

package Just.a01oopextendsdemo1;

public class Animal {
    //注意事项：
    //子类只能访问父类中非私有的成员

    //吃饭
    public void eat(){
        System.out.println("吃东西");
    }

    //喝水
    public void drink(){
        System.out.println("喝水");
    }
}
=================================================
package Just.a01oopextendsdemo1;

public class Cat extends Animal{
    //抓老鼠
    public void catMouse(){
        System.out.println("抓老鼠");
    }
}
==================================================
package Just.a01oopextendsdemo1;

public class Dog extends Animal{
    //看家
    public void lookHome(){
        System.out.println("狗看家");
    }
}
===================================================
package Just.a01oopextendsdemo1;

public class Ragdoll extends Cat{

}
==================================================
package Just.a01oopextendsdemo1;

public class LiHua extends Cat{

}
====================================================
package Just.a01oopextendsdemo1;

public class Husky extends Dog{
    public void breakHome(){
        System.out.println("哈士奇在拆家");
    }
}
=====================================================
package Just.a01oopextendsdemo1;

public class Teddy extends Dog{
    public void touch(){
        System.out.println("泰迪又在曾我的腿~");
    }
}
======================================================
package Just.a01oopextendsdemo1;

public class Test {
    public static void main(String[] args) {
       //创建对象并调用方法

       //1、创建布偶猫的对象
       Ragdoll rd = new Ragdoll();
       rd.eat();
       rd.drink();
       rd.catMouse();

       System.out.println("---------------------");

        //2、创建哈士奇的对象
        Husky h = new Husky();
        h.eat();
        h.drink();
        h.lookHome();
        h.breakHome();
    }
}
========================================================
运行结果：
吃东西
喝水
抓老鼠
---------------------
吃东西
喝水
狗看家
哈士奇在拆家

子类继承父类的内容

误区：

误区1：父类私有的东西，子类就无法继承
误区2：父类中非私有的成员，就被类继承下来

子类的继承情况：

父类中的内容	父类中的权限	子类继承情况	父类中的权限	子类继承情况	说明
构造方法	非私有	不能继承	私有	不能继承	父类的构造方法不能被子类继承
成员变量	非私有	能继承	私有	能继承	子类虽然可以继承父类私有成员变量，但是不能调用
成员方法	非私有	能继承	私有	不能继承	只有父类中的虚方法，才能被子类继承

虚方法表：

JAVA 底层会在最顶级的父类设计一个 虚方法表，
把这个类中最经常使用的方法，单独的抽取出来，放到虚方法表当中，
满足经常使用方法条件：不能被，private 、static 、和 final 修饰
在继承的时候，父类会把虚方法表交给子类，子类会相应添加自己的虚方法，构成新的虚方法表，向下继承，依次类推

继承中：成员变量访问特点

继承中成员变量访问特点：就近原则，谁离我近，我就用谁

先在局部位置找 ——> 本类成员位置找 ——> 父类成员位置找 ——> 逐级往上。
在这里插入图片描述

如果遇到重名：

System.out.println(name); <——> 从局部位置开始往上找

System.out.println(name); <——> 从本类成员位置开始往上找

System.out.println(name); <——> 从父类成员位置开始往上找

package Just.a05oopextendsdemo5;

//测试类
public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.ziShow();
    }
}

//父类
class Fu{
    String name = "Fu";
}
//子类
class Zi extends Fu{
    String name = "Zi";
        public void ziShow(){
            String name = "ziShow";
            System.out.println(name);
            System.out.println(this.name);
            System.out.println(super.name);
        }
}
=======================================================================
运行结果：
ziShow
Zi
Fu

继承中：成员方法访问特点

成员方法访问特点

直接调用满足就近原则：谁离我近，我就用谁

this调用：就近原则

super调用，直接访问父类

方法的重写

应用场景：

当父类的方法不能满足子类现在的需求时，需要进行方法重写

书写格式：

在继承体系中，子类出现了和父类一模一样的方法声明，我们就称子类这个方法是重写的方法。

@Override重写注释：

1、@Override 是放在重写后的方法上，校验子类重写时语法是否正确。

2、加上注释后如果有红色波浪线，表示语法错误。

3、建议重写方法都加@Override注解，代码安全，优雅！

package Just.a06oopextendsdemo6;

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.lunch();
    }

}

//父类
class Person{
    public void eat(){
        System.out.println("吃米饭、吃菜");
    }

    public void drink(){
        System.out.println("喝开水");
    }
}

//子类
class Student extends Person{

    @Override
    public void eat(){
        System.out.println("吃意大利面");
    }

    @Override
    public void drink(){
        System.out.println("喝凉水");
    }

    public void lunch(){
        this.eat();
        this.drink();

        super.eat();
        super.drink();
    }
}
==================================================================
运行结果：
吃意大利面
喝凉水
吃米饭、吃菜
喝开水

方法重写的本质

子类覆盖了从父类继承下来的虚方法表中的方法
在这里插入图片描述

方法从写注意事项和要求

1、重写方法的名称、形参列表必须与父类中的一致

2、子类重写父类方法时，访问权限子类必须大于等与父类（暂时了解：空着不写 < protected < public ）

3、子类重写父类方法时，返回值类型子类必须小于等于父类

4、建议：重写的方法尽量和父类保持一致

5、只有被添加到虚方法列表中的方法才能被重写

练习：利用方法的重写设计继承结构

现在有三种动物：哈士奇、沙皮狗、中华田园犬

暂时不考虑属性，只考虑行为。

请按照继承的思想特点进行继承体系的设计。

三种动物分别有以下的行为：

哈士奇：吃饭（吃狗粮）喝水、看家、拆家
沙皮狗：吃饭（吃狗粮、吃骨头）喝水、看家
中华田园犬：吃饭（吃剩饭）喝水、看家

package Just.a07oopextendsdemo7;

public class Dog {
    //吃饭
    public void eat(){
        System.out.println("吃狗粮");
    }

    //喝水
    public void water(){
        System.out.println("喝水");
    }

    //看家
    public void seeHome(){
        System.out.println("看家");
    }
}
=============================================================
package Just.a07oopextendsdemo7;

public class Husky extends Dog{
    //拆家
    public void breakHome(){
        System.out.println("拆家");
    }
}
=============================================================
package Just.a07oopextendsdemo7;

public class SharPei extends Dog{
    //父类中的方法不能满足我们的需求了，所以需要进行重写
    @Override
    public void eat(){
        //吃狗粮直接可以调用父类中的方法
        super.eat();
        System.out.println("吃骨头");
    }
}
===============================================================
package Just.a07oopextendsdemo7;

public class ChineseRuralDog extends Dog{
    //父类中的方法不能满足我们的需求了，所以需要进行重写
    @Override
    public void eat(){
        System.out.println("吃剩饭");
    }
}
===============================================================
package Just.a07oopextendsdemo7;

public class DogTest {
    public static void main(String[] args) {
        //创建对象并调用

        Husky h = new Husky();
        h.eat();
        h.water();
        h.seeHome();
        h.breakHome();

        ChineseRuralDog cd = new ChineseRuralDog();
        cd.eat();
        cd.water();
        cd.seeHome();
    }
}
================================================================
运行结果：
吃狗粮
喝水
看家
拆家
吃剩饭
喝水
看家

继承中：构造方法的特点

父类中的构造方法不会被子类继承
子类中所有的构造方法默认先访问父类中的无参构造，再执行自己
- 为什么呢？
  - 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
  - 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。
- 怎么调用父类构造方法的？
  - 子类构造方法的第一行语句默认都是：super(),不写也存在，若写且必须在第一行
  - 如果想调用父类有参构造，必须手动写 super 进行调用。

package Just.a08oopextendsdemo08;

public class Person {
    String name;
    int age;

    //无参构造
    public Person() {
        System.out.println("父类的无参构造");
    }

    //有参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}
=======================================================================
package Just.a08oopextendsdemo08;

public class Student extends Person{

    public Student(){
        //子类构造方法中隐藏的 super() 去访问父类的无参构造
        super();//==此super方法可以省略==
        System.out.println("子类的无参构造");
    }

    //调用父类中的有参构造
    public Student(String name,int age){
        super(name,age);
    }
}
========================================================================
package Just.a08oopextendsdemo08;

public class Test {
    public static void main(String[] args) {
        //创建学生对象
        Student stu1 = new Student();

        Student stu2 = new Student("zhangsan",23);
        System.out.println(stu2.name + "、" +stu2.age);
    }
}
=========================================================================
父类的无参构造
子类的无参构造
zhangsan、23

继承中构造方法的访问特点是什么？

子类不能继承父类中的构造方法但是可以通过 super 调用
子类构造方法的第一行，有一个默认的 super( );
默认先访问父类中无参构造的构造方法，再执行自己
如果想要访问父类有参构造，必须手动书写

this、super 使用内容

**this **：理解为一个变量，表示当前方法调用者的地址；
super : 代表父类存储空间

关键字	访问成员变量	访问成员方法	访问构造方法
this	this. 成员变量访问本类成员变量	this. 成员方法(…) 访问本类成员方法	this(…) 访问本类其他构造方法
super	super. 成员变量访问父类成员变量	super. 成员方法(…) 访问父类成员方法	super(…) 访问父类构造方法

**this(…) 访问其他构造方法举例 **

package Just.a09oopextendsdemo09;

public class Student {
    String name;
    int age;
    String school;

    /*
    需求：默认大学名为 “传智大学”
    利用：this 调用本类中的其他构造
     */

    public Student() {
        /*
        this() 调用本类其他构造方法
        细节：虚拟机就不会再添加super();
        其他语句写在this()下面
        */
        this(null,0,"传智大学");
    }

    public Student(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }
}
======================================================================
package Just.a09oopextendsdemo09;

public class Test {
    public static void main(String[] args) {
        Student stu = new Student();
        System.out.println(stu.school);
    }
}
======================================================================
传智大学

练习

带有继承结构的标准 Javabean 类

1、经理

成员变量：工号、姓名、工资、管理奖金

成员方法：工作（管理其他人）、吃饭（吃米饭）

2、厨师

成员变量：工号、姓名、工资

成员方法：工作（炒菜）、吃饭（吃米饭）

package Just.a10oopextendsdemo10;

public 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;
    }
    
    public String getId() {
        return id;
    }
    
    public void setId(String id) {
        this.id = id;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public double getSalary() {
        return salary;
    }
    
    public void setSalary(double salary) {
        this.salary = salary;
    }

    //工作
    public void work(){
        System.out.println("员工在工作");
    }

    //吃饭
    public void eat(){
        System.out.println("吃米饭");
    }
}
======================================================================================
package Just.a10oopextendsdemo10;

public class Manager extends Employee{
    //管理奖金
    private double bonus;

    //空参构造
    public Manager(double bonus) {

    }

    //带全部参数的构造
    //父类 + 子类
    public Manager(String id, String name, double salary, double bonus) {
        //父类有参构造
        super(id, name, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("管理其他人");
    }
}
========================================================================================
package Just.a10oopextendsdemo10;

public 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("厨师正在炒菜");
    }
}
=======================================================================================
package Just.a10oopextendsdemo10;

public class Test {
    public static void main(String[] args) {
        //创建对象并赋值调用
        Manager m = new Manager("001","张三",15000,8000);
        System.out.println(m.getId() + "," + m.getName() + "," + m.getSalary() + "," + m.getBonus());
        m.work();
        m.eat();

        System.out.println();

        Cook c = new Cook();
        c.setId("002");
        c.setName("李四");
        c.setSalary(10000);
        System.out.println(c.getId() + "," + c.getName() + "," + c.getSalary());
        c.work();
        c.eat();
    }
}
=========================================================================================
001,张三,15000.0,8000.0
管理其他人
吃米饭

002,李四,10000.0
厨师正在炒菜
吃米饭

多态

面向对象三大特征之一

认识多态

什么是多态？

同类型的对象，表现出的不同形态。

多态的表现形式：

父类类型对象名称 = 子类对象；

多态的前提：

有继承 / 实现关系；
有父类引用指向子类对象 **例子：Fu m = new Zi () ; **
有方法重写

多态的好处？

使用父类型作为参数，可以接收所有子类对象，

体现多态的扩展性与便利

package Just.a01polymorphismdemo1;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void show(){
        System.out.println(name + "," + age);
    }
}
====================================================================
package Just.a01polymorphismdemo1;

public class Student extends Person{
    @Override
    public void show() {
        System.out.println("学生的信息为：" + getName() + "," +getAge());
    }
}
====================================================================
package Just.a01polymorphismdemo1;

public class Teacher extends Person{
    @Override
    public void show() {
        System.out.println("老师的信息为：" + getName() + "," +getAge());
    }
}
====================================================================
package Just.a01polymorphismdemo1;

public class Administrator extends Person{
    @Override
    public void show() {
        System.out.println("管理员的信息为：" + getName() + "," +getAge());
    }
}
====================================================================
package Just.a01polymorphismdemo1;

public class Test {
    public static void main(String[] args) {
        //创建三个对象，并调用register方法

        Student stu = new Student();
        stu.setName("张三");
        stu.setAge(18);

        Teacher t = new Teacher();
        t.setName("王建国");
        t.setAge(30);

        Administrator admin = new Administrator();
        admin.setName("管理员");
        admin.setAge(35);

        //调用register方法
        register(stu);
        register(t);
        register(admin);

    }

    //这个方法既能接收老师、又能接收学生，还能接收管理员
    //只能把参数写成这三个类型的父亲
    //多态的运用
    public static void register(Person p){
        p.show();
    }

}
====================================================================
学生的信息为：张三,18
老师的信息为：王建国,30
管理员的信息为：管理员,35

多态中调用成员的特点

调用成员变量：编译看左边，运行也看左边。

Animal a = new Dog();

/*
调用成员变量：编译看左边，运行也看左边（看左边：定义对象时等号左边的类）
编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
运行也看左边：java运行代码的时候，实际获取的就是左边父类中的成员变量的值
*/
调用成员方法：编译看左边，运行看右边。

Animal a = new Dog();
/*
编译成员方法：编译看左边，运行看右边（看左边：定义对象时等号左边的类。看右边：定义对象时等号右边的类）
编译看左边：javac编译代码的时候，会看左边父类中有没有这个方法，如果有，编译成功，如果没有编译失败
**运行看右边：**java运行代码的时候，实际上运行的是子类中的方法
*/
理解：

Animal a = new Dog();

/*

现在用 a 去调用变量和方法

而 a 是 Animal 类型的，所以默认都会从 Animal 这个类中去找

成员变量：在子类的对象中，会把父类的成员变量也继承下来

成员方法：如果子类对方法进行了重写，那么在虚方法表中时会把父类的方法进行覆盖的。

*/
多态调用成员的内存图解

package Just.a02polymorphismdemo2;

public class test {
    public static void main(String[] args) {
        //创建对象（多态式）
        // Fu f = new Zi();
        Animal a = new Dog();
        /*
        调用成员变量：编译看左边，运行也看左边（看左边：定义对象时等号左边的类）
        编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
        运行也看左边：java运行代码的时候，实际获取的就是左边父类中的成员变量的值
        */
        System.out.println(a.name);//结果：Animal 类中，name 变量的值 —— 动物


        /*
        编译成员方法：编译看左边，运行看右边（看左边：定义对象时等号左边的类。看右边：定义对象时等号右边的类）
        编译看左边：javac编译代码的时候，会看左边父类中有没有这个方法，如果有，编译成功，如果没有编译失败
        运行看右边：java运行代码的时候，实际上运行的是子类中的方法
         */
        a.show();//结果：运行 Dog 类中的show()方法,输出————Dog --- show方法
    }
}

class Animal{
    String name = "动物";

    public void show(){
        System.out.println("Animal --- show方法");
    }
}

class Dog extends Animal{
    String name = "狗";

    @Override
    public void show() {
        System.out.println("Dog --- show方法");
    }
}

class Cat extends Animal{
    String name = "猫";

    @Override
    public void show() {
        System.out.println("Cat --- show方法");
    }
}

多态的优势和弊端

多态的优势

在多态形势下，右边对象可以实现解耦合，便于扩展和维护。

/*

Person p = new Student () ;

p.work( ); //业务逻辑发生改变时，后续代码无需修改

例如：过了几天，不想让学生去工作了，而是想让老师去工作，此时，在代码当中，只需要把创建对象的 new Student();部分修改成new Teacher();

其他地方都不用修改，再调用 work 方法的时候，它实际上运行的是修改之后的 Teacher 类里面的代码。

*/
定义方法的时候，使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利

public class Test {
    public static void main(String[] args) {
        //调用register方法
        register(stu);
        register(t);
        register(admin);
}

    //这个方法既能接收老师、又能接收学生，还能接收管理员
    //只能把参数写成这三个类型的父亲
    //多态的运用
    public static void register(Person p){
        p.show();
    }
    
}

多态的弊端

不能调用子类的特有的功能（子类中有而父类中没有的函数）

原因：当调用成员方法的时候，编译看左边，运行看右边

javac编译代码的时候，检查父类中没有这个方法，直接报错

引用数据类型的类型转换

自动类型转换

Person p = new Student ( ) ; 把子类对象，赋值给父类类型的变量由小变大

父类 <—— 子类
强制类型转换

Student s = (Student) p; 把父类类型的变量，强转成子类类型的变量由大变小

子类 <—— 父类

强制类型转换能解决什么问题？

可以转换成真正的子类类型，从而调用子类独有的功能
转换类型与真实对象类型不一致会报错
转换的时候用 instanceof 关键字进行判断

变量名 instanceof 类名

例如：a instanceof Dog 判断 a 是不是 Dog 类如果是进行强转 Dog d = (Dog)a; 转换之后变量名为 d 。如果不是，为 false 继续向下判断
```
if(a instanceof Dog){
    Dog d = (Dog)a;
    d.lookHome();
}else if(a instanceof Cat){
    Cat c = (Cat)a;
    c.catchMouse();
}else {
    System.out.println("没有这个类型，无法转换");
}
```
新特性：

先判断 a 是否为 Dog 类型，如果是，则强转成 Dog 类型，转换之后变量名为 d

如果不是，则强转成，结果直接是false
```
if(a instanceof Dog d){
    d.lookHome();
    }else if(a instanceof Cat c){
    c.catchMouse();
    }else {
    System.out.println("没有这个类型，无法转换");
     }
```

package Just.a03polymorphismdemo3;

public class Test {
    public static void main(String[] args) {
        //创建对象   （多态继承）
        Animal a = new Dog();
        Animal f = new Cat();
        //编译看左边，运行看右边
        a.eat();
        f.eat();

        //多态弊端
        //不能调用子类的特有的功能
        //报错原因？
        //当调用成员方法的时候，编译看左边，运行看右边
        //那么在编译的时候会先检查左边的父类中没有这个方法，直接报错
        //a.lookHome();

        //解决方法：
        //变回子类类型就可以了
        //细节：转换的时候不能瞎转，如果转成其他类型，就会报错。错误例子：Cat c = (Cat) a;因为上面是new Dog();

        //变换成子类型 方法一
        Dog d = (Dog)a;
        d.lookHome();

        Cat c = (Cat)f;
        c.catchMouse();
        //变换成子类型 方法二
        //if(a instanceof Dog){
            //Dog d = (Dog)a;
            //d.lookHome();
        //}else if(a instanceof Cat){
            //Cat c = (Cat)a;
            //c.catchMouse();
        //}else {
            //System.out.println("没有这个类型，无法转换");
        //}
    }
}

class Animal{
    public void eat(){
        System.out.println("动物在吃东西");
    }
}

class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookHome(){
        System.out.println("狗看家");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃小鱼干");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

练习

根据要求完成代码：

1、定义狗类

属性：年龄，颜色

行为： eat( String something ) (something 表示吃的东西)

看家lookHome方法（无参数）

2、定义猫类

属性：年龄，颜色

行为： eat( String something ) (something 表示吃的东西)

逮老鼠catchMouse方法（无参数）

3、定义Person类//饲养员

属性：姓名，年龄

行为： keepPet(Dog dog , String something)

功能：喂养宠物狗，something表示喂养的东西

行为： keepPet(Cat cat , String something)

功能：喂养宠物猫，something表示喂养的东西

生成空参有参构造，set 和 get

4、定义测试类(完成以下打印效果)：

keepPet(Dog dog , String something)方法打印的内容如下：

年龄为30岁的老王养了一只黑色的2岁的宠物

2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃

keepPet(Cat cat , String something)方法打印的内容如下：

年龄为25岁的老李养了一只灰颜色的3岁的宠物

3岁的灰颜色的猫眯着眼睛侧着鱼头吃鱼

5、思考：

1、Dog 和 Cat 都是 Animal 的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？

2、Dog 和 Cat 都是 Animal 的子类，但是都有其特有的方法，能否想办法在keepPet中调用特有方法？

package Just.a04polymorphismdemo4;

public class Animal {
    private int age;
    private String color;

    //无参构造
    public Animal() {
    }

    //有参构造
    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    //set 和 get 方法


    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //eat方法
    public void eat(String something){
        System.out.println("动物在吃" + something);
    }
}
==========================================================================
package Just.a04polymorphismdemo4;

public class Dog extends Animal{

    //空参构造
    public Dog() {
    }

    //有参构造
    public Dog(int age, String color) {
        super(age, color);
    }

    //从写eat方法
    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的"+ getColor() + "颜色的狗两只前腿死死的抱住" + something + "猛吃");
    }

    //lookHome方法
    public void lookHome(){
        System.out.println("狗在看家");
    }
}
==========================================================================
package Just.a04polymorphismdemo4;

public class Cat extends Animal{

    //无参构造
    public Cat() {
    }

    //有参构造
    public Cat(int age, String color) {
        super(age, color);
    }

    //从写eat方法
    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的猫眯着眼睛侧着头吃" + something);
    }

    //catchMouse方法
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
==========================================================================
package Just.a04polymorphismdemo4;

public class Person {
    private String name;
    private int age;

    //无参构造
    public Person() {
    }

    //有参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //set 和 get 方法


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /*
    //饲养狗
    public void keepPet(Dog dog ,String something){
        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() + "岁的狗");
        dog.eat(something);
    }

    //饲养猫
    public void keepPet(Cat cat ,String something){
        System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() + "岁的狗");
        cat.eat(something);
    }
     */

    //想要一个方法，能接收所有的动物，包括猫，包括狗
    //方法的形参：可以写这些类的父亲  Animal
    //饲养动物
    public void keepPet(Animal a ,String something){
        if(a instanceof Dog){
            Dog d = (Dog)a;
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + a.getColor() + "颜色的" + a.getAge() + "岁的狗");
            a.eat(something);
        }else if(a instanceof Cat){
            Cat c = (Cat)a;
            System.out.println("年龄为" + age + "岁的" + name + "养了一只" + a.getColor() + "颜色的" + a.getAge() + "岁的猫");
            a.eat(something);
        }
    }
}
==========================================================================
package Just.a04polymorphismdemo4;

public class Test {
    public static void main(String[] args) {
        //创建对象并调用方法
        Person p1 = new Person("老王",30);
        Dog d = new Dog(3,"黑");
        p1.keepPet(d,"骨头");
        d.lookHome();

        System.out.println();

        Person p2 = new Person("老李",25);
        Cat c = new Cat(2,"灰");
        p2.keepPet(c,"鱼");
        c.catchMouse();
    }
}
==========================================================================
年龄为30岁的老王养了一只黑颜色的3岁的狗
3岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
狗在看家

年龄为25岁的老李养了一只灰颜色的2岁的猫
2岁的灰颜色的猫眯着眼睛侧着头吃鱼
猫抓老鼠

包、final

包

什么是包？

包就是文件夹。用来管理各种不同功能的 Java 类，方便后期代码维护。

**包名的规则：**公司域名反写 + 包的作用，需要全部英文小写，见名知意。
什么是全类名？

包名 + 类名

使用其他类的规则：

使用同一个包中的类时，不需要导包。
使用 java.lang 包中的类时( 例如：String )，不需要导包。
其他情况都需要导包
如果同时使用两个包中的同名类，需要用全类名。

package Just.test;

import Just.domain.Teacher;

public class Test {
    public static void main(String[] args) {
        //创建对象

        //1、使用同一个包中的类时，不需要导包
        Student stu = new Student();
        stu.setName("王勇");
        stu.setAge(21);
        System.out.println(stu.getName() + "、" + stu.getAge());

        //2、使用 java.lang 包中的类时，不需要导包
        String s = "韩炜";
        System.out.println(s);

        //3、其他情况都需要导包
        Teacher t = new Teacher();
        
        //4、如果同时使用两个包中的同名类时，需要用全类名
        Just.Dog1.Dog d1 = new Just.Dog1.Dog();
        Just.Dog2.Dog d2 = new Just.Dog2.Dog();
    }
}

final

最终的 ——> 不可被改变的

final修饰的成分	解释	使用场景	final使用举例
方法	表明该方法是最终方法，不能被重写	定义一些规则，不希望被修改	public final void show()
类	表明该类是最终类，不能被继承		final class Fu
变量	叫做常量，只能被赋值一次	定义一个变量，不想再让他进行改变了	final int num = 21； final Student s tu = new Student(“鑫鑫”，21)

常量

实际开发中，常量一般作为系统的配置信息，方便维护，提高可读性

常量的命名规范：

单个单词：全部大写
多个单词：全部大写，单词之间用下划线隔开

细节：

final 修饰的变量是基本数据类型：那么变量存储的数据值不能发生改变。
final 修饰的变量是引用数据类型：那么变量存储的地址值不能发生改变，对象内部的可以改变。

核心：常量记录的数据是不能发生改变的。
知识回顾：字符串是不能改变的

原因：字符串的底层是被 private 和 final 修饰的

package Just.test1;

public class Test {
    public static void main(String[] args) {
        /*
        final 修饰的变量是**基本数据类型**：那么变量存储的==数据值==不能发生改变。
        final 修饰的变量是**引用数据类型**：那么变量存储的==地址值==不能发生改变，**对象内部的可以改变**。

       */
        final double PI = 3.14;

        //创建对象
        final Student STU = new Student("鑫鑫",21);
        System.out.println(STU.getName() + "、" + STU.getAge());
        STU.setName("肉墩");
        STU.setAge(20);
        System.out.println(STU.getName() + "、" + STU.getAge());

        //数组
        final int[] ARR = {1,2,3,4,5};
        //遍历数组
        for (int i = 0; i < ARR.length; i++) {
            System.out.print(ARR[i] + "、");
        }
        ARR[0] = 90;
        ARR[1] = 98;
        //遍历数组
        for (int i = 0; i < ARR.length; i++) {
            System.out.print(ARR[i] + "、");
        }
    }
}
===========================================================================================
运行结果：
鑫鑫、21
肉墩、20
1、2、3、4、5、90、98、3、4、5、
Process finished with exit code 0

权限修饰符、代码块

权限修饰符

**权限修饰符：**是用来控制一个成员能够被访问的范围的。
可以修饰成员变量，方法，构造方法，和内部类。

权限修饰符的分类：

有四种 , 作用范围由小到大：private < 空着不写（缺省/默认）< protected < public

修饰符（作用范围）	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	√
空着不写	√	√
protected	√	√	√
public	√	√	√	√

权限修饰符的使用规则

实际开发中，一般只用 private 和 public

成员变量私有
方法公开

特例：如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有。

代码块

代码块种类	位置	解释
局部代码块	方法里面	写在方法里面的一对大括号
构造代码块	方法外，类里面
静态代码块	static 修饰的静态代码块	static + 构造代码块

局部代码块：

提前结束变量的生命周期

构造代码块：

写在成员位置的代码块
作用：可以把多个构造方法中重复的代码抽取出来
执行时期：我们在创建本类对象的时候会先执行构造代码块再执行构造方法（每执行一次构造方法，便会执行一次构造代码块）

public class Student {
    private String name;
    private int age;

    //构造代码块
    {
        System.out.println("开始创建对象了");
    }

    //无参构造
    public Student() {
        System.out.println("空参构造");
    }

    public Student(String name, int age) {
        System.out.println("有参构造");
        this.name = name;
        this.age = age;
    }

静态代码块

格式：static{}

特点：需要通过static 关键字修饰，随着类的加载而加载，并且自动触发、只执行一次

使用场景：在类加载的时候，做一些数据初始化的时候使用。

public class Student {
    private String name;
    private int age;

    //静态代码块
    static {
        System.out.println("静态代码块执行了");
    }

    public Student() {
        System.out.println("空参构造");
    }

    public Student(String name, int age) {
        System.out.println("有参构造");
        this.name = name;
        this.age = age;
    }
}
========================================================
public class Test {
    //静态代码块
    static {
        System.out.println("测试静态代码块");
    }

    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();

        Student s2 = new Student("鑫鑫",21);
    }
}
========================================================
运行结果：
测试静态代码块
静态代码块执行了
空参构造
有参构造

抽象类和抽象方法

抽象方法和抽象类

**抽象方法：**将共性的行为(方法)抽取到父类之后。

由于每一个子类执行的内容是不一样的，

所以，在父类中不能确定具体的方法体。

该方法就可以定义为抽象方法。
**抽象类：**如果一个类中存在抽象方法，那么该类就必须声明为抽象类

定义格式

抽象方法定义格式：

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

注意：定义抽象方法，省略 {}
抽象类的定义格式：

public abstract class 类名 {}
子类继承抽象类之后，如何重写抽象方法

抽象类和抽象方法的注意事项

抽象类不能实例化（即不能创建对象）
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
可以有构造方法

抽象类中构造方法的作用：当创建子类对象的时，给属性进行赋值
抽象类的子类

要么重写抽象类中的所有方法

要么是抽象类

练习：编写带有抽象类的标准 Javabean 类

青蛙frog 属性：名字，年龄行为：吃虫子，喝水

狗Dog 属性：名字，年龄行为：吃骨头，喝水

山羊Sheep 属性

package Just.a02abstractdemo2;

public abstract class Animal {
    private String name;
    private int age;


    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

   public void drink(){
       System.out.println(getName() + "在喝水");
   }

   public abstract void eat();
}
===============================================================================
package Just.a02abstractdemo2;

public class Frog extends Animal{
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(getName() + "在吃虫子");
    }
}
===============================================================================
package Just.a02abstractdemo2;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(getName() + "在吃骨头");
    }
}
===============================================================================
package Just.a02abstractdemo2;

public class Sheep extends Animal{
    public Sheep() {
    }

    public Sheep(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(getName() + "在吃草");
    }
}
===============================================================================
package Just.a02abstractdemo2;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Frog f = new Frog("青蛙小绿",2);
        System.out.println(f.getName() + "、" + f.getAge());
        f.drink();
        f.eat();
        System.out.println();

        Dog d = new Dog("狗",5);
        System.out.println(d.getName() + "、" + d.getAge());
        d.drink();
        d.eat();
        System.out.println();

        Sheep s = new Sheep("山羊",7);
        System.out.println(s.getName() + "、" + s.getAge());
        s.drink();
        s.eat();
        System.out.println();
    }
}
===============================================================================
青蛙小绿、2
青蛙小绿在喝水
青蛙小绿在吃虫子

狗、5
狗在喝水
狗在吃骨头

山羊、7
山羊在喝水
山羊在吃草

接口

接口就是一种规则，是对行为的抽象。

接口的定义和使用

接口用关键字 interface 来定义

public interface 接口名 { }
接口不能实例化（即接口不能创建对象）
接口和类之间是实现关系，通过 implements 关键字表示

public class 类名 implements 接口名 { }
接口的子类（实现类）

要么重写接口中的所有抽象方法

要么是抽象类

注意：

接口和类的实现关系，可以单实现，也可以多实现。

public class 类名 implements 接口名1 , 接口名2 { }
实现类还可以在继承一个类的同时实现多个接口。

public class 类名 extends 父类 implements 接口名1 , 接口名2 { }

练习：带有接口和抽象类的标准 Javabean类

青蛙frog 属性：名字，年龄行为：吃虫子，蛙泳

狗Dog 属性：名字，年龄行为：吃骨头，狗刨

兔子属性：名字，年龄行为：吃胡萝卜
在这里插入图片描述

package Just.a01interfacedemo1;

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}
========================================================================
package Just.a01interfacedemo1;

public interface Swim {
    public abstract void swim();
}
========================================================================
package Just.a01interfacedemo1;

public class Frog extends Animal implements Swim{
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(getName() + "吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("游泳方式：蛙泳");
    }
}
========================================================================
package Just.a01interfacedemo1;

public class Dog extends Animal implements Swim{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(getName() + "吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("游泳方式：狗刨");
    }
}
========================================================================
package Just.a01interfacedemo1;

public class Rabbit extends Animal{
    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(getName() + "吃胡萝卜");
    }
}
========================================================================
package Just.a01interfacedemo1;

public class Test {
    public static void main(String[] args) {
        //创建对象
        Frog f = new Frog("小绿",1);
        System.out.println(f.getName() + "、" + f.getAge() + "岁");
        f.eat();
        f.swim();

        Dog d = new Dog("阿黄",5);
        System.out.println(d.getName() + "、" + d.getAge() + "岁");
        d.eat();
        d.swim();

        Rabbit r = new Rabbit("大白",3);
        System.out.println(r.getName() + "、" + r.getAge() + "岁");
        r.eat();
    }

}
========================================================================
小绿、1岁
小绿吃虫子
游泳方式：蛙泳

阿黄、5岁
阿黄吃骨头
游泳方式：狗刨

大白、3岁
大白吃胡萝卜

接口中成员的特点

成员变量

只能是常量

默认修饰符：public static final 在接口中定义变量的时候，可以不用写

接口名可以调用接口中的成员变量
构造方法

没有
成员方法

只能是抽象方法

默认修饰符：public abstract 在接口中定义方法的时候，可以不用写
**JDK7 以前：**接口中只能定义抽象方法。
JDK8 的新特性：接口中可以定义有方法体的方法。
JDK9 的新特性：接口中可以定义私有方法。

接口和类之间的关系

类和类的关系

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

类和接口的关系

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

当接口中有重复的方法时，类中只重写一遍

package Just.a02interfacedemo2;

public interface Inter1 {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
}
========================================================================
package Just.a02interfacedemo2;

public interface Inter2 {
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
}
========================================================================
package Just.a02interfacedemo2;

public class InterImpl implements Inter1,Inter2{

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }

    @Override
    public void method4() {

    }
}

接口和接口的关系

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

细节：如果实现类实现了最下面的子接口，那么就需要重写所有的抽象方法

package Just.a03interfacedemo3;

public interface Inter1 {
    public abstract void method1();
}
========================================================================
package Just.a03interfacedemo3;

public interface Inter2 {
    public abstract void method2();
}
========================================================================
package Just.a03interfacedemo3;

public interface Inter3 extends Inter1,Inter2{
    public abstract void method3();
}
========================================================================
package Just.a03interfacedemo3;

public class InterImpl implements Inter3{

    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    @Override
    public void method3() {

    }
}

上面的例子中，Inter3 继承了 Inter1 和 Inter2 ，所以当类InterImpl 使用接口Inter3 时，重写了Inter3 中的抽象方法，还重写了Inter3 重 Inter1 和 Inter2 中继承的方法。

有接口和抽象类的标准 Javabean 类

练习：编写带有接口和抽象类的标准 Javabean 类

我们现有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。

为了出国交流，跟乒乓球相关人员都需要学习英语。

请用所有知识分析，在这个案例中，哪些是具体类，哪些是抽象类，哪些是接口？

乒乓球运动员：姓名，年龄，学打乒乓球，说英语

乒乓球教练：姓名，年龄，教打乒乓球，说英语

篮球运动员：姓名，年龄，学打篮球

篮球教练：姓名，年龄，教打篮球
在这里插入图片描述

package Just.a04interfacedemo4;

public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
========================================================================
package Just.a04interfacedemo4;

public abstract class Athlete extends Person{
    public Athlete() {
    }

    public Athlete(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}
========================================================================
package Just.a04interfacedemo4;

public abstract class Coach extends Person{
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}
========================================================================
package Just.a04interfacedemo4;

public interface Speak {
    public abstract void speak();
}
========================================================================
package Just.a04interfacedemo4;

public class TableTennisPlayer extends Athlete implements Speak{
    public TableTennisPlayer() {
    }

    public TableTennisPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学习打乒乓球");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员在说英语");
    }
}
========================================================================
package Just.a04interfacedemo4;

public class BasketballPlayer extends Athlete{
    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学习学打篮球");
    }
}
========================================================================
package Just.a04interfacedemo4;

public class TableTennisCoach extends Coach implements Speak{
    public TableTennisCoach() {
    }

    public TableTennisCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练在教如何打乒乓球");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练在说英语");
    }
}
========================================================================
package Just.a04interfacedemo4;

public class BasketballCoach extends Coach{
    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练在教如何打篮球");
    }
}
========================================================================
鑫鑫、21
乒乓球运动员在学习打乒乓球
乒乓球运动员在说英语

肉墩、35
篮球教练在教如何打篮球

JDK8开始接口中新增的方法

1、JDK7以前：接口中只能定义抽象方法。

2、JDK8的新特性：接口中可以定义有方法体的方法。（默认方法、静态方法）。

默认方法

允许在接口中定义默认方法，需要使用关键字 default 修饰

作用：解决接口升级的问题

接口中默认方法的定义格式：

格式：Public default 返回值类型方法名 ( 参数列表 ) { }
范例：public default void show( ){ }

接口中默认方法的注意事项：

默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉 default 关键字；如果默认方法在类中重写，创建此类的对象，调用默认方法，调用的是重写后的方法。
public 可以省略，default 不能省略。
如果实现了多个接口，多个接口中存在相同名字的默认方法，**子类（实现类）**就必须对该方法进行重写

public interface InterA {
    
    public abstract void method();
    
    public default void show(){
        System.out.println("InterA接口中的默认方法 --- show");
    }
}
========================================================================
public interface InterB {
    public default void show(){
        System.out.println("InterB接口中的默认方法 --- show");
    }
}
========================================================================
public class InterImpl implements InterA,InterB {
    @Override
    public void method() {
        System.out.println("实现类重写的抽象方法");
    }

    //由于接口 InterA和 InterB 中存在相同名字的默认方法，子类（实现类）就必须对该方法进行重写
    @Override
    public void show() {
        System.out.println("重写接口中的默认方法");
    }
}
========================================================================
public class Test {
    public static void main(String[] args) {
        //创建对象
        InterImpl ii = new InterImpl();
        //调用重写的method方法
        ii.method();
        //调用默认方法show
        ii.show();
    }
}
========================================================================
运行结果：
实现类重写的抽象方法
重写接口中的默认方法

静态方法

允许在接口中定义静态方法，需要用 **static **修饰

接口中静态方法的定义格式：

格式：public static 返回值类型方法名 ( 参数列表 ) { }
范例：public static void show( ) { }

接口中静态方法的注意事项：

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

public interface Inter {

    public abstract void method();

    public static void show(){
        System.out.println("Inter 接口中的静态方法");
    }
}
========================================================================
public class InterImpl implements Inter{

    @Override
    public void method() {
        System.out.println("InterImpl 重写的抽象方法");
    }

    //不叫重写，只是InterImpl 中的方法与 接口 Inter里面的方法重名
    public static void show(){
        System.out.println("InterImpl 类中的静态方法");
    }
}
========================================================================
public class Test {
    public static void main(String[] args) {
        //调用接口中的静态方法
        Inter.show();

        //调用实现类中的静态方法
        InterImpl.show();
        InterImpl ii = new InterImpl();
        ii.method();
    }
}
========================================================================
运行结果：
Inter 接口中的静态方法
InterImpl 类中的静态方法
InterImpl 重写的抽象方法

3、JDK9的新特性：接口中可以定义私有方法。

接口中私有方法的定义格式：

为默认方法服务：

格式1：private 返回值类型方法名（参数列表）{ }
范例1： public void show ( ) { }

为静态方法服务

格式2：private static 返回值类型方法名（参数列表）{ }
范例2： public static void method ( ) { }

public interface InterA {

    public default void show1(){
        System.out.println("show1 默认方法开始执行了");
        show3();
    }

    public default void show2(){
        System.out.println("show1 默认方法开始执行了");
        show3();
    }
    //普通的私有方法，给默认方法服务的
    private void show3(){
        System.out.println("记录程序在运行过程的各种细节，这里有100行代码");
    }
}
========================================================================
public interface InterB {

    public static void show1(){
        System.out.println("show1 静态方法开始执行了");
        show3();
    }

    public static void show2(){
        System.out.println("show1 静态方法开始执行了");
        show3();
    }

    //静态的私有方法，给静态的方法服务的
    private static void show3(){
        System.out.println("记录程序在运行过程的各种细节，这里有100行代码");
    }
}
========================================================================
public class InterImpl implements InterA,InterB{

}
========================================================================
public class Test {
    public static void main(String[] args) {
        //创建对象
        InterImpl ii = new InterImpl();
        //调用默认方法
        ii.show1();
        ii.show2();

        System.out.println();
        //调用静态方法
        InterB.show1();
        InterB.show2();
    }
}
========================================================================
运行结果：
show1 默认方法开始执行了
记录程序在运行过程的各种细节，这里有100行代码
show2 默认方法开始执行了
记录程序在运行过程的各种细节，这里有100行代码

show1 静态方法开始执行了
记录程序在运行过程的各种细节，这里有100行代码
show2 静态方法开始执行了
记录程序在运行过程的各种细节，这里有100行代码

接口的应用

1、接口代表规则，是行为的抽象。想要让哪个类拥有一个行为，就让这个类实现对应的接口就可以了。

2、当一个方法的参数是接口时，可以传递接口所有实现类的对象，这种方式称之为接口多态。

适配器设计模式

设计模式( Design pattern ) 是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验总结。

使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

简单理解：设计模式就是各种套路。
适配器设计模式： 解决接口与接口实现类之间的矛盾问题。

总结：

当一个接口中抽象方法过多，但是我只要使用其中一部分的时候，就可以采用适配器设计模式
书写步骤：
- 编写中间类XXXAdapter ,实现对应的接口
- 让接口中的抽象方法进行空实现
- 让真正的实现类继承中间类 ，并重写需要用的方法
- 为了避免其他类创建适配器的对象，中间的适配器类用 abstract 进行修饰
**注意：**如果真正实现类还继承其他类，由于类不能多继承，所以用下面解决方案：

让中间类继承真正实现类本要继承的类，再让真正实现类，继承中间类，通过间接继承，让真正实现类继承其本要继承的类

public interface Inter {
    public abstract void method1();
    public abstract void method2();
    public abstract void method3();
    public abstract void method4();
    public abstract void method5();
    public abstract void method6();
    public abstract void method7();
    public abstract void method8();
    public abstract void method9();
    public abstract void method10();
}
========================================================================
public abstract class InterAdapter implements Inter{
    //所有重写方法进行空实现
    @Override
    public void method1() {

    }

    @Override
    public void method2() {

    }

    ...............
}
========================================================================
public class InterImpl extends InterAdapter{
    //需要用到哪个方法，就重写哪个方法

    @Override
    public void method5() {
        System.out.println("只要用第五个方法");
    }
}

内部类

内部类基本概念

1、什么是内部类？

写在一个类里面的类就叫作内部类

举例：在 A 类的内部定义 B 类，B 类就被称为内部类
在这里插入图片描述

2、什么时候用到内部类？

B 类表示的事物是 A 类的一部分，且 B 单独存在没有意义。

比如：汽车的发动机，ArrayList 的迭代器，人的心脏等等

3、内类的详情

内部类表示的事物是外部类的一部分
内部类单独出现没有任何意义

4、内部类的访问特点：

内部类可以直接访问外部类，包括私有
外部类要访问内部类的成员，必须创建对象

练习：

需求：写一个 Javabean 类描述汽车。

属性：汽车的品牌，车龄，颜色，发动机的品牌，使用年限。

public class Car {
    String carName;
    int carAge;
    String carColor;

    public void show(){
        System.out.println(carName);
        //System.out.println(engineName);
        //外部类要访问内部类的成员，必须创建对象
        Engine e = new Engine();
        System.out.println(e.engineName);
    }

    class Engine{
        String engineName;
        int engineAge;

        public void show(){
            System.out.println(engineName);
            //内部类可以直接访问外部类的成员，包括私有
            System.out.println(carName);
        }
    }
}

成员内部类(了解)

成员内部类代码书写

写在成员位置的，属于外部类的成员（ 类内，方法外）
成员内部类可以被一些修饰符所修饰，比如：private 、默认、protected、public、static 等
- 注意：成员内部类定义为 private 的时候，在外界不能直接创建其对象。
在成员内部类里面，JDK16 之前不能定义静态变量，JDK16 开始才可以定义静态变量。

public class Car { 外部类

String carName ;

int carAge ;

int carColor ;

class Engine { 成员内部类

String engineName ;

int engineAge ;

}

}

创建成员内部类对象

方式一：

在外部类中编写方法，对外提供内部类的对象。

使用场景：当用 private 权限修饰符修饰内部类的时候

public class Outer {
    //内部类
    private class Inner{
    }
    //格式一：外部类编写方法，对外提供内部类对象
    public Inner getInstance(){
        return new Inner();
    }
}
调用方法：
//外部类的对象
Outer o = new Outer();
方法一：用变量接收外部类的方法  
Object inner = o.getInstance();
System.out.println(inner);
方法二：        
System.out.println(o.getInstance());

方式二：

直接创建格式：外部类名.内部类名对象名 = 外部类对象.内部类对象；

范例：Outer.Inner oi = new Outer().new Inter() ;

使用场景：非使用 private 权限修饰符

成员内部类获取外部类成员变量

外部类成员变量和内部类成员变量重名时，在内部类如何访问？

System.out.println(Outer.this.变量名）

package Just.ao3innerclassdemo3;

public class Outer {
    private int a = 10;

    class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
            System.out.println(a);  //30
            System.out.println(this.a);  //20
            //Outer.this  获取了外部类对象的地址值
            System.out.println(Outer.this.a);  //10
        }
    }
}
========================================================================
package Just.ao3innerclassdemo3;

public class Test {
    public static void main(String[] args) {
        //创建内部类对象对象，并调用show方法
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}
========================================================================
运行结果：
30
20
10

静态内部类(了解)

静态内部类也是成员内部类的一种

静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象

public class Car { 外部类

String carName ;

int carAge ;

int carColor ;

static class Engine { 成员内部类

String engineName ;

int engineAge ;

}

==创建静态内部类对象的格式：==外部类名.内部类名对象名 = new 外部类名.内部类名( ) ;

范例：Outer.Inter oi = new Outer.Inter();

==调用非静态方法的格式：==先创建对象，用对象调用

范例：Outer.Inter oi = new Outer.Inter();

oi.show1();

==调用静态方法的格式：==外部类名.内部类名.方法名();

范例：Outer.Inter.show2();

package Just.ao4innerclassdemo4;

public class Outer {

    int a = 10;
    static int b = 20;
    //静态内部类
    static class Inter{
        //非静态方法
        public void show1(){
            System.out.println("非静态的方法被调用了");
            //静态内部类访问外部类中的非静态变量和静态方法，需要创建对象
            Outer o = new Outer();
            System.out.println(o.a);
            //静态内部类直接访问外部类中的静态变量和静态方法
            System.out.println(b);
        }
        //静态方法
        public static void show2(){
            System.out.println("静态的方法被调用了");
            //静态内部类访问外部类中的非静态变量和静态方法，需要创建对象
            Outer o = new Outer();
            System.out.println(o.a);
            //静态内部类直接访问外部类中的静态变量和静态方法
            System.out.println(b);
        }

    }
}
========================================================================
package Just.ao4innerclassdemo4;

public class Test {
    public static void main(String[] args) {
        //创建静态内部类的对象
        //只要是静态的东西，都可以用类名.直接获取
        Outer.Inter oi = new Outer.Inter();
        //调用非静态方法
        oi.show1();
        //调用静态方法
        Outer.Inter.show2();
    }
}
========================================================================
运行结果：
非静态的方法被调用了
10
20
静态的方法被调用了
10
20

局部内部类(了解)

1、将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。

2、外界无法直接使用，需要在方法内部创建对象并使用。

3、该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

package Just.ao5innerclassdemo5;

public class Outer {
    //外部类的成员
    int b = 20;
    public void show(){
        //方法内的局部变量
        int a = 10;
        //局部内部类
        class Inner{
            String name;
            int age;

            public void method1(){
                //内部类可以直接访问外部类的成员，也可以访问方法内的局部变量
                System.out.println(a);
                System.out.println(b);
                System.out.println("局部内部类中的methodl方法");
            }

            public static void method2(){
                System.out.println();
            }
        }
        //外界是无法直接使用局部内部类，需要在方法内部创建对象并使用
        //创建局部内部类的对象
        Inner i = new Inner();
        System.out.println(i.name);
        System.out.println(i.age);
        i.method1();
        Inner.method2();
    }

}
========================================================================
package Just.ao5innerclassdemo5;

public class Test {
    public static void main(String[] args) {

        //调用show方法，让代码执行
        Outer o = new Outer();
        o.show();
    }
}

匿名内部类(掌握)

匿名内部类：隐藏了名字的内部类，可以写在成员位置、局部位置

格式：

new (父)类名或者接口名 () { 继承 \ 实现

重写方法； 方法重写

}； 创建对象

格式细节：

包含了继承或实现，方法重写，创建对象。

整体就是一个类的子类对象或者接口的实现类对象

解释：new （父）类名或者接口名（）；是 new 出来的没有名字的类的对象

**真正没有名字的类是 { } **

{ } 与前面的对象，要么是继承关系，要么是实现关系

在 { } 里面重写抽象方法

总结：匿名内部类是集：{ } 匿名类 ——> 继承或接口 ——> 方法重写 ——> 创建匿名类对象于一体的存在

整体，呈现出来的是匿名类的对象

使用场景：

当方法的参数是接口时或者类时，

以接口为例，可以传递这个接口的实现类对象，

如果实现类只要使用一次，就可以用匿名内部类简化代码。

举例:

package Just.ao6innerclassdemo6;

public interface Swim {
    public abstract void swim();

}
========================================================================
package Just.ao6innerclassdemo6;

public abstract class Animal {
    public abstract void eat();
}
========================================================================
package Just.ao6innerclassdemo6;

public class Test {
    public static void main(String[] args) {

        //编写匿名内部类的代码
        new Swim(){
            @Override
            public void swim() {
                System.out.println("重写了游泳的方法");
            }
        };
        /*
        new Animal(){
            @Override
            public void eat() {
                System.out.println("重写了eat方法");
            }
        };
        上面注释的代码表示：创建了 Animal 子类的对象，其中包括，匿名类继承父类——> 匿名类重写父类的抽方法——> 创建匿名类的对象
        */
        //在测试类中调用下面的 method 方法？
        method(
                //把 Animal 子类（匿名类）的对象，作为参数，调用的 method 方法
                new Animal() {
                    @Override
                    public void eat() {
                        System.out.println("狗吃骨头");
                    }
                }
        );
    }

    public static void method(Animal a){//Animal a = 子类对象；符合：标准多态
        a.eat();//编译看左边，运行看右边
    }
}
========================================================================
运行结果：
狗吃骨头

补充：匿名内部类的其他使用

package Just.ao6innerclassdemo6;

public class Test2 {
    public static void main(String[] args) {

        /*下面的整体，可以理解为 Swim接口的 实现类对象
           我们可以把此对象，赋值给一个 Swim接口的类型的 变量 ————> 进而实现 接口的多态
         */
        Swim s = new Swim(){

            @Override
            public void swim() {
                System.out.println("重写游泳后的方法1");
            }
        };
        //用对象 s 调用实现类的重写方法
        //编译看左边，运行看右边
        s.swim();


        /*下面的整体，可以理解为 Swim接口的 实现类对象
           既然是实现类的对象，那可以调用类的方法
           首先调用实现类中的方法
         */
        new Swim(){

            @Override
            public void swim() {
                System.out.println("重写游泳后的方法2");
            }
        }.swim();
    }
}
========================================================================
运行结果：
重写游泳后的方法1
重写游泳后的方法2