Javase（四）

我会带着你远行 2023-10-13 19:44 28阅读 0赞

### 继承、重写、多态、抽象类、接口 ###

#### 01 继承 ####

*  概念：两个类的关系
 *  特点：继承是描述两个类的关系
 *  优势：规范代码，避免不必要的错误
 *  格式：（配合重写食用更佳）

class 子类 extends 父类 {
      属性名
      方法名
            }

*  继承中，子类会把父类的所有方法和属性都继承下来（除了private）
 *  子类也可以拥有父类没有的属性和方法，子类直接可以使用父类的方法
 *  Java中，只能单继承，一个子类有且仅有一个父类，但一个父类可以有多个子类

// 人，属性：姓名和性别
    public class Person {
                public String name = "人";
                // 0未知，1男，2女
                public String sex = "0";
            public void eat() {
                System.out.println("吃饭");
        }
    }
    // 中国人，属性：姓名，性别，生肖
    public class ChinesePerson extends Person {
            public String name = "中国人";
            // 生肖
            public String shengxiao;
            public void kungfu() {
                System.out.println("功夫");
        }
    }
    // 测试
    public static void main(String[] args) {
            ChinesePerson chinesePerson = new ChinesePerson();
    // 子类没有定义sex属性，但是也有性别属性，这就是继承了父类
            System.out.println(chinesePerson.sex); // 0
    // 子类、父类可以有同名属性
            System.out.println(chinesePerson.name); // 中国人
    // 子类可以有父类没有的属性
            System.out.println(chinesePerson.shengxiao); // null
    // 子类没有定义eat方法，但是可以使用
      chinesePerson.eat();
      // 子类可以有父类没有的方法
      chinesePerson.kungfu();
    }

### 02 supper ###

*  supper（）与this（）调用空构造器类似，但调用的是父类的空构造器
 *  子类new了一个对象，父类构造器必定先被调用，然后再调用子类的构造器（在子类没有设置父类构造器，则构造器内部默认调用super()）。

*  如果子类的构造器中调用了父类的有参构造器，那么系统默认的父类无参构造器失效

*  super()的调用必须要放在第一行（与this（）必须要放在第一行冲突，故this（）和supper（）不能同时调用）

*  super可以表示父类的引用，使用super和this来区分父类和子类的同名属性和方法，这就是方法内部区别不同参数的本质

// ChinesePerson中添加方法test()
            public void test() {
      // 优先找当前类的name属性，找不到就到父类找
            System.out.println(name); // 中国人
      // 当前类的sex属性无设置，就找到到父类的默认设置0
            System.out.println(sex); // 0
      // 使用this关键字指定获取子类还是父类的同名属性
            System.out.println(this.name); // 中国人
            System.out.println(super.name); // 人
      // 方法和属性一样
            super.eat();//通过super直接添加父类方法
        }

##### 注意：子类用this，父类用supper #####

#### 03 重写 ####

*  概念：（override），也称作覆盖

*  特点：返回值和形参都不能改变。即方法的名字不变，核心重写（JDK7以后）

*  优点：省取名字的时间，且方法之间有一定关系
 *  重载（overload）：同一个类中，有相同的方法名，但是参数的类型或者参数的个数不同，这两个方法就是重载。

// 人类
    public class Person {
        public String name = "人";
        // 人都会吃饭，子类继承时，每个区域的吃饭方式都不一样，所以需要重写
                public void eat() {
            System.out.println("吃饭");
        }
    }
        // 中国人
    public class ChinesePerson extends Person{
        public String name = "中国人";
        // 对eat方法进行重写，实现了具体的吃饭方式
                @Override
                public void eat() {
                    System.out.println("使用筷子吃饭");
            } 
     }
    // 印度人
    public class IndiaPerson extends Person{
            public String name = "印度人";
        //不同子类按需求重写
            @Override
            public void eat() {
                System.out.println("使用手吃饭");
        }
    }

#### 04 多态 ####

*  概念：同一个行为具有不同的表现形式，执行一段代码

*  特点：不同的子类可以使用相同的方法
 *  优点：代码复用性高，逻辑性强
 *  前提条件：
    
     *  继承父类的子类
     *  父类方法被覆盖的（已经重写的）子类
     *  父类引用指向子类对象（格式）

//父类 对象名=new 子类（）;
    Person person=new ChinesePerson();

*  多态的模式中，引用的是子类的方法，调用的父类的属性

// 人
    public class Person {
                public String name = "人";
                // 人都会吃饭，具体怎么吃还不清楚
                public void eat() {
                    System.out.println("吃饭");
    }
                 public void buyFood() {
                    System.out.println("买饭");
        }
    }
    // 中国人
    public class ChinesePerson extends Person{
                public String name = "中国人";
                // 重写父类eat方法，实现具体的吃饭方式
                 @Override
                public void eat() {
                System.out.println(name + "用筷子吃饭");
        }
    }
    // 英国人
                public class EnglishPerson extends Person{
                public String name = "英国人";
                @Override
                public void eat() {
                System.out.println(name + "用刀叉吃饭");
        }
    }
                // 用手吃饭
                public class IndiaPerson extends Person{
                    public String name = "印度人";
                     @Override
                     public void eat() {
                        System.out.println(name + "用手吃饭");
        }
    }
    // main函数测试1。
    public static void main(String[] args) {
                // 子类对象赋值给父类的引用（父类类型的变量）
                Person person1 = new ChinesePerson();
                Person person2 = new IndiaPerson();
                // 执行的是子类的方法
                person1.eat(); // 中国人用筷子吃饭
                person2.eat(); // 印度人用手吃饭
    }
                // main函数测试2。实现食堂排队买饭场景。
                // 我们封装ganfan()方法，过程为 买饭 + 吃饭。
                public static void main(String[] args) {
                // 使用数组模拟排队，全部进行多态处理
                Person[] persons = {
                    new ChinesePerson(),
                    new IndiaPerson(), 
                    new EnglishPerson(),
                    new IndiaPerson()
                };
      // 循环排队干饭
            for(int i = 0; i < persons.length; i++) 
            {
                ganfan(persons[i]);
                // 运行过程中才确定是什么对象，不需要考虑子类间的差异
                System.out.println("-----------");
            }
    }  
    // 买饭 + 吃饭
    // 干饭方法不需要具体知道是什么人吃饭
    // 通过多态，实现同一数组存储数据类型相同，具体对象不同
    public static void ganfan(Person person) {
            person.buyFood();
            person.eat();
    }

#### 05 抽象类 ####

*  概念：类的模板
 *  特点：不能创建具体的对象，用于规范类的格式
 *  优点：避免了子类的设计随意
 *  格式

public abstract class 类名 {
        // 抽象方法
        public abstract 返回值 方法名();//不能有方法体就是{}
    }

*  语法：（由abstract修饰）
    
     *  抽象类不能实例化（没有具体对象），只能被继承（extends），然后子类实例化（创建对象）
     *  继承抽象类的非抽象类（子类如果不是抽象类）必须实现抽象方法（重写）
     *  抽象类中可以没有抽象方法（由abstract修饰的方法），有抽象方法的类只能存在于抽象类
     *  抽象类可以继承抽象类（抽象类的子类不用重写抽象方法），可以不用实现抽象方法
     *  抽象的方法不能private，final，static修饰（abstract与以上修饰词冲突）

#### 06 接口 ####

*  概念：一种类型的约定
 *  特点：互不依赖，但有一点的相同性（类似抽象类）

*  优点：比抽象类常用，一个子类只能继承一个抽象类，但可以有多个接口
 *  格式

interface 接口名 {
        public abstract void open();
        //由abstract修饰的方法一定要被子类重写
        public abstract void close();
    }

*  语法
    
     *  接口也不能实例化（也没有具体对象），需要有类使用（implements）来实现接口，并且实现接口中的抽象方法（由abstract修饰的方法）
     *  接口中的方法系统默认是抽象的（默认被abstract修饰）
     *  接口的方法不能使用private和final、static修饰。（abstract与以上修饰词冲突）
     *  接口可以多继承
     *  接口可以定义常量，常量默认会带public static final 。该常量不能修改，一般我们通过【接口名.常量】（与static修饰的类的属性类似）来访问。

public abstract class Door {
        public abstract void open();
        public abstract void close();
    }
    public interface Door {
        public abstract void open();
        public abstract void close();
    }
        // 接口强调行为，报警的动作
    public interface Alram {
            void alarm();
    }
        // 抽象类强调事物，门具备开和关固有的行为特性
    public abstract class Door {
        void open();
        void close();
    }
    // 如果是警报门。具备门基本的特征，所以继承Door。又具备报警的功能就实现Alarm接口进行扩展。
    class AlarmDoor extends Door implements Alarm {
      void oepn() {
       //....
     }
      void close() {
       //....
     }
      void alarm() {
       //....
     }
    }
    // 如果是普通门，把implements Alarm去掉即可。
    class AlarmDoor extends Door {
      void oepn() {
          //....
     }
      void close() {
            //....
      }
    }
    // 假如是一个火灾警报器，不具备门的特性，我们直接实现Alarm接口就好了
    class FireAlarm implements Alarm {
        void alarm() {
            //....
        }
    }

##### 区别：接口强调行为，抽象类强调具体一类事物的共性 #####