Java基础篇：继承 + 抽象 + 接口 + 多态

冷不防 2022-12-01 05:15 221阅读 0赞

# 字符串的分割方法 #

package String;
    /* * 分割字符串的方法： * public String[] split(String regex)：按照参数的规则，将字符串切分成为若干部分。 * * 注意事项： * split方法的参数其实是一个“正则表达式”。 * 如果按照英文句点，"."进行切分，必须写"\\."(两个反斜杠) * */
    public class Demo05StringSplit { 
        public static void main(String[] args) { 
            String str1 = "abc,bbb,dnf";
            String[] array1 = str1.split(",");
            for (int i = 0; i < array1.length; i++) { 
                System.out.println(array1[i]); // abc bbb dnf
            }
            System.out.println("=====");
    
            String str2 = "AAA BBB DDD";
            String[] array2 = str2.split(" ");
            for (int i = 0; i < array2.length; i++) { 
                System.out.println(array2[i]); // AAA BBB DDD
            }
    
            System.out.println("=====");
    
            String str3 = "DDD.NNN.FFF";
            String[] array3 = str3.split("\\.");
            for (int i = 0; i < array3.length; i++) { 
                System.out.println(array3[i]); // DDD NNN FFF
            }
        }
    }

## 练习：按指定格式拼接字符串 ##

package String;
    /* * 题目：定义一个方法：把数组[1,2,3]按照指定格式成一个字符串，格式参照如下：[word1#word2#word3] * * 分析： * 1.首先准备一个int[]数组，内容是：1,2,3 * 2.定义一个方法，用来将数组变成字符串 * * 三要素： * 返回值类型：String * 方法名称：fromArrayToString * 参数列表：int[] * 3.格式：[word1#word2#word3] * 用到：for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个 * 4.调用方法：得到返回值，并打印结果字符串 * */
    public class Demo06StringParams { 
        public static void main(String[] args) { 
            int[] array = { 1,2,3};
    
            String result = fromArrayToString(array);
            System.out.println(result); // [word1#word2#word3]
        }
        public static String fromArrayToString(int[] array) { 
            String str = "[";
            for (int i = 0; i < array.length; i++) { 
                if (i == array.length - 1) { 
                    str += "word" + array[i] + "]";
                }else { 
                    str += "word" + array[i] + "#";
                }
            }
            return str;
        }
    }

## 练习：统计输入的字符串中各种字符的个数 ##

package String;
    
    import java.util.Scanner;
    
    /* * 题目：键盘输入一个字符串，并且统计其中各种字符出现的次数， * 种类有：大写字母、小写字母、数字、其他 * * 思路： * 1.既然用到键盘输入，肯定是Scanner * 2.键盘输入的是字符串，那么：String str = sc.next(); * 3.定义四个变量：分别代表四和字符各自的出现次数。 * 4.需要对字符串一个字、一个字检查，String --> char[],方法是：toCharArray(); * 5.遍历char[]字符数组，对当前字符的种类进行判断，并且用四个变量进行++动作。 * 6.打印输出四个变量，分别代表四种字符出现次数。 * */
    public class Demo07StringCount { 
        public static void main(String[] args) { 
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入一个字符串：");
            String input = sc.next(); // 获取键盘输入的字符串
    
            int countUpper = 0; // 大写字母
            int countLower = 0; // 小写字母
            int countNumber = 0; // 数字
            int countOther = 0; // 其他字符
    
            char[] charArray = input.toCharArray();
            for (int i = 0; i < charArray.length; i++) { 
                char ch = charArray[i]; // 当前单个字符
                if('A' <= ch && ch <= 'Z') { 
                    countUpper++;
                } else if ('a' <= ch && ch <= 'z') { 
                    countLower++;
                } else if ('0' <= ch && ch <= '9') { 
                    countNumber++;
                } else { 
                    countOther++;
                }
            }
    
            System.out.println("大写字母有：" + countUpper);
            System.out.println("小写字母有：" + countLower);
            System.out.println("数字有：" + countNumber);
            System.out.println("其他字符有：" + countUpper);
    
        }
    }

## 静态static关键字概述 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center]

## 静态static关键字修饰成员变量 ##

package Static;
    
    public class Student { 
        private String name; // 姓名
        private int age; // 年龄
        static String room; // 所在教室
        private static int idCounter = 0; // 学号计数器，每当new了一个新对象的时候，idCounter++
    
        // 无参构造方法
    
        public Student() { 
            this.idCounter = ++idCounter;
        }
    
        // 有参构造方法
    
        public Student(String name, int age) { 
            this.name = name;
            this.age = age;
            this.idCounter = ++idCounter;
        }
    
    
        // Getter/Setter方法
    
    
        public static int getIdCounter() { 
            return idCounter;
        }
    
        public static void setIdCounter(int idCounter) { 
            Student.idCounter = idCounter;
        }
    
        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 Static;
    
    public class Demo01Static { 
        public static void main(String[] args) { 
            Student one = new Student("吴奇隆",19);
            one.room = "101教室";
            System.out.println("姓名：" + one.getName() + ",年龄：" + one.getAge() + ",教室：" + one.room + "，学号：" + one.getIdCounter());
    
            Student two = new Student("刘诗诗",18);
            System.out.println("姓名：" + two.getName() + ",年龄：" + two.getAge() + ",教室：" + two.room + "，学号：" + two.getIdCounter());
        }
    }

## 静态static关键字修饰成员方法 ##

package Static;
    
    public class MyClass { 
    
        int num; // 成员变量
        static int numStatic; // 静态变量
    
        // 成员方法
        public void method(){ 
            System.out.println("这是一个成员方法");
            // 成员方法可以访问成员变量、静态变量
            System.out.println(num);
            System.out.println(numStatic);
        }
    
        // 静态方法
        public static void methodStatic(){ 
            System.out.println("这是一个静态方法");
            // 静态方法可以访问静态变量
            System.out.println(numStatic);
    
            // 静态不能直接访问非静态【重点】
            // System.out.println(num); //错误写法!!!
    
            // 静态方法中不能使用this关键字
            // System.out.println(this);// 错误写法!!!
        }
    }

package Static;
    /* * 一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。 * 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。 * 如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。 * * 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。 * 静态变量：类名称.静态变量 * 静态方法：类名称.静态方法() * * 注意事项： * 1.静态不能直接访问非静态。 * 原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。 * “先人不知道后人，但是后人知道先人” * 2.静态方法当中不能用this。 * 原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。 * */
    public class Demo02StaticMethod { 
        public static void main(String[] args) { 
            MyClass obj = new MyClass(); // 首先创建对象
            // 然后才能使用没有static关键字内容
            obj.method();
    
            // 对于静态方法来说：可以通过对象名进行调用，也可以直接通过类名称来调用。
            obj.methodStatic(); // 正确，不推荐。这种写法在编译之后也会被javac编译成为："类名称.静态方法名"
            MyClass.methodStatic(); // 正确，推荐用类名称进行调用
    
            // 对于本类当中的静态方法，可以省略类名称
            myMethod();
            Demo02StaticMethod.myMethod(); // 完全等效
        }
    
        public static void myMethod() { 
            System.out.println("自己的方法!");
        }
    }

## 静态static的内存图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 1]

## 静态代码块 ##

package Static;
    
    public class Person { 
        static { 
            System.out.println("静态代码块");
        }
        public Person() { 
            System.out.println("动态代码块");
        }
    }

package Static;
    /* * 静态代码块的格式是： * * public class 类名称 { * static { * // 静态代码块的内容 * } * } * * 特点：当第一次用到本类时，静态代码块执行唯一的一次。 * 静态内容总是优先于非静态，所以静态代码块比构造方法先执行。 * * 静态代码块的典型用途： * 用来一次性地对静态成员变量进行赋值。 * */
    public class Demo04StaticPerson { 
        public static void main(String[] args) { 
            Person one = new Person();
            Person two = new Person();
        }
    }

# 数组工具类arrays #

package Array;
    
    import java.util.Arrays;
    
    /* * java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现 * 数组常见的操作。 * * public static String toString(数组)；将参数数组变成字符串（按照默认格式：[元素1、元素2、元素3、...]） * public static void sort(数组)；按照默认升序（从小到大）对数组的元素进行排序。 * * 注意事项： * 1.如果是数值，sort默认按照升序从小到大 * 2.如果是字符串，sort默认按照字母升序 * 3.如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持（今后学习） * * * */
    public class Demo01Arrays { 
        public static void main(String[] args) { 
            int[] intArray = { 10,20,30};
            // 将int[]数组按照默认格式变成字符串
            String intStr = Arrays.toString(intArray);
            System.out.println(intStr); // [10, 20, 30]
    
            int[] array1 = { 2,1,3,10,6};
            Arrays.sort(array1);
            System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]
    
            String[] array2 = { "bbb","ccc","aaa"};
            Arrays.sort(array2);
            System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
        }
    }

## arrays练习：字符串倒序排列 ##

package Array;
    
    import java.util.Arrays;
    /* * 题目：请使用Arrays相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。 * * */
    public class ArraysTest { 
        public static void main(String[] args) { 
            // 定义随机的字符串
            String str = "ysUreadfSRWEJDSFJJ123";
            /* 如何进行升序排列：sort 必须是一个数组，才能用Arrays.sort方法 String --> 数组，用toCharArray */
            char[] chars = str.toCharArray();
    
            // 升序排序
            Arrays.sort(chars); // 对字符数组进行升序排列
            // 反向遍历打印
            for (int i = chars.length - 1; i >= 0; i--) { 
                System.out.print(chars[i]); // ysrfedaWUSSRJJJFED321
            }
        }
    }

# 数学工具类Math #

package Math;
    /* * java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。 * * public static double abs(double num);获取绝对值。有多种重载 * public static double ceil(double num);向上取整 * public static double floor(double num);向下取整 * public static long round(double num);四舍五入 * * Math.PI代表近似的圆周率常量（double）。 * * */
    public class Demo01Math { 
        public static void main(String[] args) { 
            // 获取绝对值
            System.out.println(Math.abs(3.14)); // 3.14
            System.out.println(Math.abs(-3.14)); // 3.14
            System.out.println(Math.abs(0)); // 0
            System.out.println("=========");
    
            // 向上取整
            System.out.println(Math.ceil(3.9)); // 4.0
            System.out.println(Math.ceil(-3.1)); // -3.0
            System.out.println(Math.ceil(3.1)); // 4.0
            System.out.println(Math.ceil(3.0)); // 3.0
            System.out.println("=========");
    
            // 向下取整，抹零
            System.out.println(Math.floor(30.1)); // 30.0
            System.out.println(Math.floor(-30.9)); // -31.0
            System.out.println(Math.floor(31.0)); // 31.0
            System.out.println("=========");
    
            // 四舍五入
            System.out.println(Math.round(20.4)); // 20
            System.out.println(Math.round(10.5)); // 11
            System.out.println("=========");
    
        }
    }

## 练习题：小学模考真题 ##

package Math;
    /* * 题目：计算在 -10.8~5.9之间，绝对值大于6或者小于2.1的整数有多少个？ * * 分析： * 1.既然已经确定了范围，for循环 * 2.起点位置-10.8应该转换成为-10，两种办法： * 2.1 可以使用Math.ceil方法，向上（向正方向）取整 * 2.2 强转成为int，自动舍弃所有小数位 * 3.每一个数字都是整数，所以步进表达式应该是num++,这样每次都是+1的。 * 5.一旦发现了一个数字，需要让计数器++进行统计。 * * 备注：如果使用Math.ceil方法，-10.8可以变成-10.0。 * 注意：double也是可以进行++的。 * */
    public class Demo01MathPractise { 
        public static void main(String[] args) { 
            int count = 0; // 符合要求的数量
            double min = -10.8;
            double max = 5.9;
            // 【变量i强转成为int】 这样处理，变量i就是区间之内所有的整数
            for(int i = (int) min;i < max;i++) { 
                int abs = Math.abs(i); // 绝对值
                if(abs > 6 || abs < 2.1) { 
                    System.out.println(i);
                    count++;
                }
            }
            System.out.println("总共有：" + count); // 9
        }
    }

# 继承的概述 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 2]

## 继承的格式 ##

创建对象

package Extends;
    /* * 在继承的关系中："子类就是一个父类"。也就是说：子类可以被当做父类看待。 * 例如：父类是员工，子类是讲师，那么"讲师就是一个员工"。关系：is-a * * 定义父类的格式：（一个普通的类定义） * public class 父类名称 { * // ... * } * 定义子类的格式： * public class 子类名称 extends 父类名称 { * // ... * } * */
    public class Demo01Extends { 
        public static void main(String[] args) { 
            // 创建了一个子类对象
            Teacher teacher = new Teacher();
            // Teacher类当中虽然什么都没写，但是会继承来自父类的method方法。
            teacher.method();
    
            // 创建了一个子类助教
            Assistant assistant = new Assistant();
            // Assistant类当中虽然什么都没写，但是会继承来自父类的method方法。
            assistant.method();
        }
    }

定义一个父类：员工

package Extends;
    // 定义一个父类：员工
    public class Employee { 
        // 定义一个方法
        public void method() { 
            System.out.println("方法执行");
        }
    }

*  定义子类：讲师

package Extends;
    /* * 定义了一个员工的子类：讲师 * */
    public class Teacher extends Employee{ 
    
    }

*  定义子类：助教

package Extends;
    // 定义了一个员工的子类：助教
    public class Assistant extends Employee { 
    
    }

## 继承中成员变量的访问特点 ##

package Extends.Demo01;
    /* * 在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式： * * 直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有则向上找。 * 间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则向上找。 * */
    public class Demo01ExtendsField { 
        public static void main(String[] args) { 
            Fu fu = new Fu(); // 创建父类对象
            System.out.println(fu.numFu); // 20 只能使用父类的东西，没有任何子类的内容
    
            Zi zi = new Zi(); // 创建子类对象
            System.out.println(zi.numZi); // 10
            System.out.println(zi.numFu); // 20
            System.out.println("=============");
    
            // 等号左边是谁，就优先用谁，没有则向上找
            System.out.println(zi.num); // 100 优先子类 Zi zi = new Zi();
            // System.out.println(zi.abc); // 到处都没有，编译报错!
            System.out.println("=============");
    
            // 这个方法是子类的，优先用子类的，没有再向上找
            zi.methodZi(); // 100
            // 这个方法是在父类当中定义的
            zi.methodFu(); // 200
        }
    }

*  父类

package Extends.Demo01;
    
    public class Fu { 
        // 成员变量
        int numFu = 20;
        int num = 200;
        // 成员方法
        public void methodFu() { 
            // 使用的是本类当中的，不会向下找子类的
            System.out.println(num);
        }
    }

*  子类

package Extends.Demo01;
    
    public class Zi extends Fu{ 
        // 成员变量
        int numZi = 10;
        int num = 100;
        // 成员方法
        public void methodZi() { 
            // 因为本类当中有num,所以这里用的是本类的num
            System.out.println(num);
        }
    }

## 区分子类方法中重名的三种变量 ##

package Extends.Demo02;
    /* * 局部变量： 直接写成员变量名 * 本类的成员变量： this.成员变量名 * 父类的成员变量： super.成员变量名 * */
    public class Demo01ExtendsField { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
            zi.method();
        }
    }

*  父类

package Extends.Demo02;
    
    public class Fu { 
        int num = 20;
    }

*  子类

package Extends.Demo02;
    
    public class Zi extends Fu{ 
        int num = 10;
        public void method() { 
            int num = 30;
            System.out.println(num); // 30 局部变量
            System.out.println(this.num); // 10 本类的成员变量
            System.out.println(super.num); // 20 父类的成员变量
        }
    }

## 继承中成员方法的访问特点 ##

package Extends.Demo03;
    /* * 在父子类的继承关系当中，创建子类对象，访问成员方法的规则： * 创建的对象是谁，就优先用谁，如果没有则向上找。 * * 注意事项： * 无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。 * */
    public class Demo01ExtendsMethod { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
    
            zi.methodFu(); // 父类方法执行
            zi.methodZi(); // 子类方法执行
    
            // 创建的是new了子类对象，所以优先用子类方法
            zi.method(); // 子类重名方法执行
        }
    }

*  父类

package Extends.Demo03;
    
    public class Fu { 
        public void methodFu(){ 
            System.out.println("父类方法执行");
        }
    
        public void method(){ 
            System.out.println("父类重名方法执行");
        }
    }

*  子类

package Extends.Demo03;
    
    public class Zi extends Fu{ 
        public void methodZi(){ 
            System.out.println("子类方法执行");
        }
    
        public void method(){ 
            System.out.println("子类重名方法执行");
        }
    }

## 继承中方法的覆盖重写：概念与特点 ##

package Extends.Demo03;
    /* * 在父子类的继承关系当中，创建子类对象，访问成员方法的规则： * 创建的对象是谁，就优先用谁，如果没有则向上找。 * * 注意事项： * 无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。 * 重写（Override） * 概念：在继承关系当中，方法的名称一样，参数列表也一样。 * * 重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。 * 重载（Overload）：方法的名称一样，参数列表【不一样】。 * * 方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。 * */
    public class Demo01ExtendsMethod { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
    
            zi.methodFu(); // 父类方法执行
            zi.methodZi(); // 子类方法执行
    
            // 创建的是new了子类对象，所以优先用子类方法
            zi.method(); // 子类重名方法执行
        }
    }

*  父类

*  子类

## 继承中方法的覆盖重写：注意事项 ##

package Extends.Demo04;
    /* * 方法覆盖重写的注意事项： * * 1.必须保证父子类之间方法的名称相同，参数列表也相同 * @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。 * 这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。 * * 2.子类方法的返回值必须【小于等于】父类方法的返回值范围 * 小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。 * * 3.子类方法的权限必须【大于等于】父类方法的权限修饰符。 * 小扩展提示：public > protected > (default) > private * 备注：(default)不是关键字default，而是什么都不写，留空。 * */
    public class Demo04Override { 
        public static void main(String[] args) { 
    
        }
    }

*  父类

package Extends.Demo04;
    
    public class Fu { 
        public Object method() { 
            return null;
        }
    }

*  子类

package Extends.Demo04;
    
    public class Zi extends Fu{ 
        @Override
        public Object method() { 
            return null;
        }
    }

## 继承中方法的覆盖重写：应用场景 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 3]

package Extends.Demo05;
    
    public class Demo01Phone { 
        public static void main(String[] args) { 
            Phone phone = new Phone();
            phone.call(); // 打电话
            phone.send(); // 发短信
            phone.show(); // 显示号码
            System.out.println("==========");
            newPhone newPhone = new newPhone();
            newPhone.call(); // 打电话
            newPhone.send(); // 发短信
            newPhone.show(); // 显示号码 显示姓名 显示头像
                    
        }
    }

*  父类

package Extends.Demo05;
    // 本来的老款手机
    public class Phone { 
        public void call() { 
            System.out.println("打电话");
        }
    
        public void send() { 
            System.out.println("发短信");
        }
    
        public void show() { 
            System.out.println("显示号码");
        }
    }

*  子类

package Extends.Demo05;
    // 定义一个新手机，使用老手机作为父类
    public class newPhone extends Phone{ 
        @Override
        public void show(){ 
            super.show(); // 把父类的show方法拿过来重复利用
            // 自己子类再来添加更多内容
            System.out.println("显示姓名");
            System.out.println("显示头像");
        }
    }

## 继承中构造方法的访问特点 ##

package Extends.Demo06;
    /* * 继承关系中，父子类构造方法的访问特点： * 1.子类构造方法当中有一个默认隐含的"super()"调用，所以一定是先调用的父类构造，后执行的子类构造 * 2.子类构造可以通过super关键字，调用父类重载构造 * 3.super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。 * * 总结： * 1.子类必须调用父类构造方法：不写则赠送super(); * 写了则用写的指定的super调用，super只能有一个，还必须是第一个 * */
    public class Demo06Constructor { 
        public static void main(String[] args) { 
            // 创建子类对象
            Zi zi = new Zi();
        }
    }

*  父类

package Extends.Demo06;
    
    public class Fu { 
        // 有参构造
        public Fu(int num){ 
            System.out.println("父类有参构造方法");
        }
    
        // 无参构造
        public Fu(){ 
            System.out.println("父类无参构造方法");
        }
    
    }

*  子类

package Extends.Demo06;
    
    public class Zi extends Fu{ 
        // 无参构造
        public Zi(){ 
            // super(); // 在调用父类无参构造方法
            super(20); // 调用父类重载的构造方法
            System.out.println("子类构造方法");
        }
    
    // public void method() { 
    // super(); // 错误写法! 只有子类构造方法，才能调用父类构造方法。
    // }
    }

# super关键字的三种用法 #

package Extends.Demo07;
    
    public class Demo07Super { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
            zi.method();
            zi.methodZi();
        }
    }

*  父类

package Extends.Demo07;
    
    public class Fu { 
        int num = 30;
    
        public void method() { 
            System.out.println("父类方法");
        }
    }

*  子类

package Extends.Demo07;
    /* * super关键字的用法有三种： * 1.在子类的成员方法中，访问父类的成员变量。 * 2.在子类的成员方法中，访问父类的成员方法。 * 3.在子类的构造方法中，访问父类的构造方法。 * */
    public class Zi extends Fu{ 
        int num = 20;
    
        public Zi() { 
            super();
        }
    
        public void methodZi() { 
            System.out.println(num); // 20
            System.out.println(super.num); // 父类中的30
        }
    
        public void method() { 
            super.method(); // 访问父类中的method
            System.out.println("子类方法");
        }
    }

# this关键字的三种用法 #

package Extends.Demo08;
    
    public class Fu { 
        int num = 30;
    }

package Extends.Demo08;
    /* * super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种。 * 1.在本类的成员方法中，访问本类的成员变量。 * 2.在本类的成员方法中，访问本类的另一个成员方法。 * 3.在本类的构造方法中，访问本类的另一个构造方法。 * 注意事项： * 1.this(...) 调用也必须是构造方法的第一个语句。【唯一一个】 * 2.super和this两种构造调用，不能同时使用 * */
    public class Zi extends Fu{ 
        int num = 20;
    	
        // 无参构造
        public Zi() { 
            // super(); // 这一行不再赠送
            this(123); // 本类的无参构造，调用本类的有参构造
            // this(12,13); // 错误写法【注意事项1】
        }
    	// 有参构造
        public Zi(int n) { 
            this(1,2); // 一个参数，可以调用多个参数
        }
    	// 有参构造
        public Zi(int n,int m) { 
            // this(6); // 多个参数不能调用一个参数
        }
    
        public void showNum() { 
            int num = 10;
            System.out.println(num); // 局部变量
            System.out.println(this.num); // 本类中的成员变量
            System.out.println(super.num); // 父类中的成员变量
        }
    
        public void methodA() { 
            System.out.println("AAA");
        }
    
        public void methodB() { 
            this.methodA(); // 在本类的成员方法中，访问本类的另一个成员方法
            System.out.println("BBB");
        }
    }

# super与this关键字图解 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 4]

# Java继承的三个特点 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 5]

# 抽象的概念： #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 6]

## 抽象方法和抽象类的格式 ##

package Extends.Demo10;
    /* * 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结算。 * 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。 * */
    public abstract class Animal { 
        // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定
        public abstract void eat();
        
        // 这是普通的成员方法
        public void normalMethod() { 
            
        }
    }

## 抽象方法和抽象类的使用 ##

package Extends.Demo10;
    
    public class Demo01Main { 
        public static void main(String[] args) { 
            // Animal animal = new Animal(); // 错误写法：第一步：不能直接创建new抽象类对象
    
            // 第四步：创建子类对象进行使用
            Cat cat = new Cat();
            cat.eat();
        }
    }

*  父类

package Extends.Demo10;
    /* * 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结算。 * 抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。 * * 如何使用抽象类和抽象方法： * 1.不能直接创建new抽象类对象。 * 2.必须用一个子类来继承抽象父类。 * 3.子类必须覆盖重写抽象父类当中所有的抽象方法。 * 覆盖重写（实现），子类去掉抽象方法的 abstract 关键字，然后补上方法体大括号 * 4.创建子类对象进行使用。 * */
    public abstract class Animal { 
        // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定
        public abstract void eat();
    
        // 这是普通的成员方法
        public void normalMethod() { 
    
        }
    }

*  子类

package Extends.Demo10;
    
    // 第二步：用一个子类来继承抽象父类
    public class Cat extends Animal{ 
    
        /* * 第三步：子类必须覆盖重写抽象父类当中所有的抽象方法。 * 覆盖重写（实现），子类去掉抽象方法的 abstract 关键字，然后补上方法体大括号 * */
    
        @Override
        public void eat() { 
            System.out.println("猫吃鱼");
        };
    }

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

关于抽象类的使用，以下为语法上要注意的细节

1.  抽象类【**不能创建对象**】。如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
    
    > 理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2.  抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
    
    > 理解：子类的构造方法中，有默认的super()，需要访问父类构造方法
    
        package Extends.Demo11;
        
        public class DemoMain { 
            public static void main(String[] args) { 
                Zi zi = new Zi();
                zi.eat();
            }
        }
    
     *  父类
    
        package Extends.Demo11;
        // 抽象父类
        public abstract class Fu { 
        
            public Fu() { 
                System.out.println("抽象父类构造方法执行");
            }
        
            public abstract void eat();
        }
    
     *  子类
    
        package Extends.Demo11;
        
        public class Zi extends Fu{ 
        
            public Zi() { 
                // super(); // 通过赠送的super();运行父类中的 Fu 构造方法
                System.out.println("子类构造方法执行");
            }
        
            @Override
            public void eat() { 
                System.out.println("吃饭饭");
            }
        }
3.  抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
    
    ###### 【抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可】 ######
    
    > 理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
    
        package Extends.Demo11;
        /* * 一个抽象类不一定含有抽象方法， * 只要保证抽象方法所在的类是抽象类，即可。 * * 这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。 * */
        public abstract class MyAbstract { 
        
        }
4.  抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。
    
    > 理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

# 发红包案例-分析 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 7]

# 发红包案例-实现 #

package SendMoney;
    
    import java.util.ArrayList;
    
    public class MainPacket { 
        public static void main(String[] args) { 
    
            // 群主对象
            Manager manager = new Manager("群主",100);
    
            Member one = new Member("成员A",0);
            Member two = new Member("成员B",0);
            Member three = new Member("成员B",0);
    
            manager.show();
            one.show();
            two.show();
            three.show();
            System.out.println("============");
    
            // 群主总共发20块钱，分成3个红包
            ArrayList<Integer> redList = manager.send(20,3);
            // 三个普通成员收红包
            one.receive(redList);
            two.receive(redList);
            three.receive(redList);
    
            manager.show(); // 100-20=80
            // 6,6,8 随机分给三个人
            one.show();
            two.show();
            three.show();
        }
    }

*  群主

package SendMoney;
    
    import java.util.ArrayList;
    
    // 群主的类
    public class Manager extends User{ 
        public Manager() { 
    
        }
        // 快捷键：Alt + insert
        public Manager(String name, int money) { 
            super(name, money);
        }
        public ArrayList<Integer> send(int totalMoney,int count) { 
    
            // 首先需要一个集合，用来存储若干个红包的金额
            ArrayList<Integer> redList = new ArrayList();
    
            // 首先看一下群主自己有多少钱
            int leftMoney = super.getMoney(); // 群主当前余额
            if(totalMoney > leftMoney) { 
                System.out.println("余额不足");
                return redList; // 返回空集合
            }
    
            // 扣钱，其实就是重新设置余额
            super.setMoney(leftMoney - totalMoney);
    
            // 发红包需要平均拆分成为count份
            int avg = totalMoney / count;
            int mod = totalMoney % count; // 余数，也就是甩下的零头
    
            // 除不开的零头，包在最后一个红包当中
            // 下面把红包一个一个放到集合当中
            for (int i = 0; i < count; i++) { 
                redList.add(avg);
            }
    
            // 最后一个红包
            int last = avg + mod;
            redList.add(last);
    
            return redList;
        }
    }

*  用户类

package SendMoney;
    
    public class User { 
    
        private String name; // 姓名
        private int money; // 余额，也就是当前用户拥有的钱数
    
        // 无参构造
        public User() { 
        }
    
        // 有参构造
        public User(String name, int money) { 
            this.name = name;
            this.money = money;
        }
    
        // 展示一下当前用户有多少钱
        public void show() { 
            System.out.println("我叫：" + name + ",我有多少钱：" + money);
        }
    
        // Getter/Setter方法
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getMoney() { 
            return money;
        }
    
        public void setMoney(int money) { 
            this.money = money;
        }
    }

*  成员

package SendMoney;
    
    import java.util.ArrayList;
    import java.util.Random;
    // 普通成员
    public class Member extends User{ 
        public Member() { 
    
        }
        public Member(String name,int money) { 
            super(name, money);
        }
        public void receive(ArrayList<Integer> list) { 
            // 从多个红包当中随便抽取一个，给我自己
            // 随机获取一个集合当中的索引编号
            int index = new Random().nextInt(list.size());
            // 根据索引，从集合当中删除，并且得到被删除的红包，给我自己
            Integer delta = list.remove(index);
            // 当前成员自己本来有多少钱
            int money = super.getMoney();
            // 加法，并且重新设置回去
            super.setMoney(money + delta);
    
        }
    
    }

# 接口的定义 #

## 接口的定义基本格式 ##

## 接口的抽象方法定义和使用 ##

package Demo33;
    /* * 在任何版本的java中，接口都能定义抽象方法： * 格式：public abstract 返回值类型 方法名称(参数列表); * * 注意事项： * 1.接口当中的抽象方法：修饰符必须是两个固定的关键字：public abstract * 2.这两个关键字修饰符，可以选择性地省略。（今天刚学，所以不推荐） * 3.方法的三要素，可以随意定义。 * */
    public interface MyInterfaceAbstract { 
        // 这是一个抽象方法
        public abstract void methodAbs1();
    
        // 这也是抽象方法
        abstract void methodAbs2();
        
        // 这是一个抽象方法
        public void methodAbs3();
    
        // 这也是抽象方法
        void methodAbs4();
    }

*  使用

package Demo33;
    /* * 接口就是多个类的公共规范。 * 接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。 * * 如何定义一个接口的格式： * public interface 接口名称 { * // 接口内容 * } * * 备注：换成了关键字 interface 之后，编译生成的字节码文件仍然是：.java --> .class * * 如果是 Java 7,那么接口中可以包含的内容有： * 1.常量 * 2.抽象方法 * * 如果是Java 8,还可以额外包含有： * 3.默认方法 * 4.静态方法 * * 如果是Java 9,还可以额外包含有： * 5.私有方法 * * 接口使用步骤： * 1.接口不能直接使用，必须有一个"实现类" 来 "实现" 该接口。 * 格式： * public class 实现类名称 implements 接口名称 { * // ... * } * 2.接口的实现类必须覆盖重写（【实现】）接口中所有的抽象方法。 * 【实现】：去掉abstract关键字，加上方法体大括号。 * 3.创建实现类的对象，进行使用。 * * 注意事项： * 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。 * */
    public class Interface { 
    
        public static void main(String[] args) { 
            // 错误写法：不能直接new接口对象使用。
            // MyInterfaceAbstract inter = new MyInterfaceAbstract();
    
            // 创建实现类的对象使用：
            MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
            impl.methodAbs1();
            impl.methodAbs2();
        }
    
    }

## 接口的默认方法定义和使用 ##

package Demo33;
    /* 接口的默认方法： * 解决接口升级的问题 * 拼接函数模型 * 1.接口的默认方法：可以通过接口实现类对象，直接调用。 * 2.接口的默认方法，也可以被接口实现类进行覆盖重写。 * */
    public class Demo02Interface { 
        public static void main(String[] args) { 
            // 创建了实现类对象
            MyInterfaceDefaultA a = new MyInterfaceDefaultA();
            a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类。
    
            // 调用默认方法：如果实现类当中没有，会向上找接口
            a.methodDefault(); // 这是新添加的默认方法
            System.out.println("========");
    
            MyInterfaceDefaultB b = new MyInterfaceDefaultB();
            b.methodAbs();
            b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
        }
    }

*  抽象方法

package Demo33;
    /* * 从Java 8开始，接口里允许定义默认方法。 * 格式： * public default 返回值类型 方法名称(参数列表) {方法体} * * 备注：接口当中的默认方法，可以解决接口升级的问题。 * */
    public interface MyInterfaceDefault { 
    
        // 抽象方法
        public abstract void methodAbs();
    
        // 新添加了一个抽象方法,原来的方法会受影响。解决方法：改成默认方法
        // public abstract void methodAbs2();
    
        // 新添加的方法，改为默认方法
        public default void methodDefault() { 
            System.out.println("这是新添加的默认方法");
        }
    }

*  抽象方法A

package Demo33;
    
    public class MyInterfaceDefaultA implements MyInterfaceDefault{ 
    
        @Override
        public void methodAbs() { 
            System.out.println("实现了抽象方法，AAA");
        }
    }

*  抽象方法B

package Demo33;
    
    public class MyInterfaceDefaultB implements MyInterfaceDefault{ 
    
        @Override
        public void methodAbs() { 
            System.out.println("实现了抽象方法，BBB");
        }
    
        @Override
        public void methodDefault() { 
            System.out.println("实现类B覆盖重写了接口的默认方法");
        }
    
    }

## 接口的静态方法定义和使用 ##

package Static.MyInter;
    /* * 注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。 * 正确用法：通过接口名称，直接调用其中的静态方法。 * 格式： 接口名称.静态方法名(参数)； * */
    public class Demo01Interface { 
        public static void main(String[] args) { 
            
            // 错误写法。因为：【不能通过接口实现类的对象来调用接口当中的静态方法】
    
            // MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl(); // 创建了实现类对象
            // impl.methodStatic();
            
    
            // 直接通过接口名称调用静态方法 静态和对象没关系（【上面的做法为啥new一个对象呢？所以上面的做法错误且没有必要】），但是和类有关系。
            MyInterfaceStatic.methodStatic();
    
    
        }
    }

*  接口的静态方法

package Static.MyInter;
    /* * 从Java 8开始，接口当中允许定义静态方法： * 格式： * public static 返回值类型 方法名称(参数列表) { 方法体 } * * 提示：就是将 abstract 或者 default 换成 static 即可，带上方法体。 * */
    public interface MyInterfaceStatic { 
        public static void methodStatic(){ 
            System.out.println("这是接口的静态方法");
        }
    }

*  是一个类实现一个接口用的关键字：`implements`

package Static.MyInter;
    
    public class MyInterfaceStaticImpl implements MyInterfaceStatic{ 
    
    }

## 接口的私有方法定义和使用 ##

package Static.privateA;
    /* * 问题描述： * 我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。 * 但是这个共有方法不应该让实现类使用，应该是私有化的。 * * 解决方案： * 从Java 9开始，接口当中允许定义私有方法。 * 1.普通私有方法，解决多个默认方法之间重复代码问题 * 格式：private 返回值类型 方法名称(参数列表) { 方法体 } * 2.静态私有方法，解决多个静态方法之间重复代码问题 * 格式：private static 返回值类型 方法名称(参数列表) { 方法体 } * * */
    public interface MyInterfacePrivateA { 
        public default void methodDefault1() { 
            System.out.println("默认方法1");
    // methodCommon();
        }
    
        public default void methodDefault2() { 
            System.out.println("默认方法2");
    // methodCommon();
        }
    
    // private void methodCommon() { 
    // System.out.println("AAA");
    // System.out.println("BBB");
    // System.out.println("CCC");
    // }
    }

*  MyInterfacePrivateA页面

package Static.privateA;
    
    public class MyInterfacePrivateAImpl implements MyInterfacePrivateA { 
        public void methodAnother() { 
            // 直接访问到了接口中的默认方法，这样是错误的
            // methodCommon();
        }
    }

*  MyInterfacePrivateB页面

package Static.privateA;
    
    public interface MyInterfacePrivateB { 
        public static void methodStatic1() { 
            System.out.println("静态方法1");
    // methodStaticCommon();
        }
    
        public static void methodStatic2() { 
            System.out.println("静态方法2");
    // methodStaticCommon();
        }
    
    // private static void methodStaticCommon() { 
    // System.out.println("AAA");
    // System.out.println("BBB");
    // System.out.println("CCC");
    // }
    }

*  Demo01Interface页面

package Static.privateA;
    
    public class Demo01Interface { 
        public static void main(String[] args) { 
            MyInterfacePrivateB.methodStatic1();
            MyInterfacePrivateB.methodStatic2();
    
            // 错误写法：
            // MyInterfacePrivateB.methodStaticCommon();
        }
    }

## 接口的常量定义和使用 ##

package Const;
    
    public class Demo01Interface { 
    
        public static void main(String[] args) { 
            // 访问接口当中的常量
            System.out.println(MyInterfaceConst.NUM_OF_MY_CLASS);
        }
    
    }

package Const;
    /* * 接口当中也可以定义"成员变量"，但是必须使用 public static final 三个关键字进行修饰。 * 从效果上看，这其实就是接口的【常量】 * 格式： public static final 数据类型 常量名称 = 数据值； * * 备注：一旦使用 final 关键字进行修饰，说明不可改变。 * * 注意事项： * 1.接口当中的常量，可以省略 public static final，注意：不写也照样是这样。 * 2.接口当中的常量，必须进行赋值；不能不赋值。 * 3.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。(推荐命名规则) * * */
    public interface MyInterfaceConst { 
        // 这其实就是一个常量，一旦赋值，不可以修饰
        public static final int NUM_OF_MY_CLASS = 10;
    }

## 接口的内容小结 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 8]

## 继承父类并实现多个接口 ##

package Demo01;
    /* * 使用接口的时候，需要注意： * 1.接口是没有静态代码块或者构造方法的。 * 2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。 * 3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。 * 4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。 * 5.如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。 * 6.一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。 * * 格式： * public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB { // 覆盖重写所有抽象方法 } * */
    public class Demo01Interface { 
        public static void main(String[] args) { 
            Zi zi = new Zi();
            zi.method(); // 父类方法
        }
    }

*  实现类

package Demo01;
    
    // 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。 【添加关键字 abstract】
    public abstract class MyInterfaceAbstract implements MyInterfaceA,MyInterfaceB{ 
        @Override
        public void methodA() { 
    
        }
    
        @Override
        public void methodAbs() { 
    
        }
    
        @Override
        public void methodDefault() { 
    
        }
    
        // 假设没有覆盖重写这个接口
    // @Override
    // public void methodB() { 
    //
    // }
    
    }

*  接口

package Demo01;
    
    public interface MyInterface { 
        public default void method() { 
            System.out.println("接口的默认方法");
        }
    }

*  MyInterfaceImpl类

package Demo01;
    
    // 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
    public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{ 
        @Override
        public void methodA() { 
            System.out.println("覆盖重写了A方法");
        }
    
        @Override
        public void methodAbs() { 
            System.out.println("覆盖重写了AB接口都有的抽象方法");
        }
    
        @Override
        public void methodB() { 
            System.out.println("覆盖重写了B方法");
        }
    
        @Override
        public void methodDefault() { 
            System.out.println("对多个接口当中冲突的默认方法进行了覆盖重写");
        }
    }

*  接口A

package Demo01;
    
    public interface MyInterfaceA { 
        // 错误写法：接口不能有静态代码块
        // static {}
    
        // 错误写法：接口不能有构造方法
        // public MyInterface{}
    
        public abstract void methodA();
    
        public abstract void methodAbs();
    
        public default void methodDefault() { 
            System.out.println("默认方法AAA");
        }
    
    }

*  接口B

package Demo01;
    
    public interface MyInterfaceB { 
        // 错误写法：接口不能有静态代码块
        // static {}
    
        // 错误写法：接口不能有构造方法
        // public MyInterface{}
    
        public abstract void methodB();
    
        public abstract void methodAbs();
    
        public default void methodDefault() { 
            System.out.println("默认方法BBB");
        }
    }

*  父类

package Demo01;
    
    public class Fu { 
        public void method() { 
            System.out.println("父类方法");
        }
    }

*  子类

package Demo01;
    
    public class Zi extends Fu implements MyInterface{ 
    
    }

## 接口之间的多继承 ##

package Demo01.study;
    /* * 1.类与类之间是单继承的，直接父类只有一个； * 2.类与接口之间是多实现的。一个类可以实现多个接口 * 3.接口与接口之间是多继承的。 * * 注意事项： * 1.多个父接口当中的抽象方法如果重复，没关系。 * 2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写。【而且带着default关键字】 * */
    public class Demo01Relations { 
    
    }

package Demo01.study;
    
    public class MyInterfaceImpl implements MyInterface{ 
        @Override
        public void method() { 
    
        }
    
        @Override
        public void methodA() { 
    
        }
    
        @Override
        public void methodB() { 
    
        }
    
        @Override
        public void methodCommon() { 
    
        }
    }

*  子接口

package Demo01.study;
    
    // 接口：含有接口A和接口B的内容，另外还有自己的内容。
    
    /* * 这个子接口当中有几个方法？答：4个 * methodA 来源于接口A * methodB 来源于接口B * methodCommon 来源于接口A和B * method 来源于我自己 * */
    public interface MyInterface extends MyInterfaceA,MyInterfaceB{ 
        // 自己的抽象方法
        public abstract void method();
    
        @Override
        default void methodDefault() { 
    
        }
    }

*  接口A

package Demo01.study;
    
    // 接口A
    public interface MyInterfaceA { 
    
        // 抽象方法
        public abstract void methodA();
    
        public abstract void methodCommon();
    
        public default void methodDefault() { 
            System.out.println("AAA");
        }
    
    }

*  接口B

package Demo01.study;
    
    // 接口B
    public interface MyInterfaceB { 
    
        // 抽象方法
        public abstract void methodB();
    
        public abstract void methodCommon();
    
        public default void methodDefault() { 
            System.out.println("BBB");
        }
    
    }

# 多态的概述 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 9]

## 多态的格式与使用 ##

package Multi;
    
    /* * 代码当中体现多态性，其实就是一句话：父类引用指向子类对象。 * 格式：父类名称 对象名 = new 子类名称(); 或者 接口名称 对象名 = new 实现类名称(); * * */
    public class Demo01Multi { 
        public static void main(String[] args) { 
            // 使用多态的写法
            // 左侧父类的引用，指向了右侧子类的对象
            Fu obj = new Zi();
    
            obj.method();  // 子类方法
            obj.methodFu(); // 父类特有方法
        }
    }

*  父类

package Multi;
    
    public class Fu { 
        // 成员方法
        public void method() { 
            System.out.println("父类方法");
        }
    
        public void methodFu() { 
            System.out.println("父类特有方法");
        }
    }

*  子类

package Multi;
    
    public class Zi extends Fu{ 
    
        // 成员方法
        @Override
        public void method() { 
            System.out.println("子类方法");
        }
    }

## 多态中成员变量和成员方法的使用特点 ##

*  运行代码

package Multi.Demo02;
    /* * 在多态的代码当中，成员方法的访问规则是： * 看new的是谁，就优先用谁，没有则向上找。 * * 口诀：编译看左边，运行看右边。 * * 对比一下： * 成员变量：编译看左边，运行还看左边。 * 成员方法：编译看左边，运行看右边。 * * */
    public class MultiMethod { 
        public static void main(String[] args) { 
            Fu obj = new Zi(); // 多态
    
            /* * 编译看左边：左边是 Fu obj * 1. obj.method(); Fu 当中有method方法 => 运行看右边：但是因为 new Zi() 优先用子类的方法 * 2. obj.methodFu(); Fu 当中有method方法 => 运行看右边：但是因为 new Zi() 优先用子类的方法,子类没有，父类有。向上找到父类 * */
    
            // 父子都有这个方法，但是因为 new Zi() 优先用子类的方法
            obj.method(); // 打印结果：子类方法
    
            // 子类没有，父类有。向上找到父类
            obj.methodFu();  // 父类特有方法
    
            // 编译看左边，左边是 Fu obj，Fu当中没有methodZi方法，所以编译报错。
            // obj.methodZi(); // 错误写法!
    
        }
    }

*  成员变量不能进行覆盖重写，只有成员方法可以覆盖重写

package Multi.Demo02;
    /* * 访问成员变量的两种方式： * * 1.直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找 * 2.间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找 * */
    public class MultiField { 
        public static void main(String[] args) { 
            // 使用多态的写法，父类引用指向子类对象
            Fu obj = new Zi();
            System.out.println(obj.num); // 父类 10
            System.out.println("==========");
    
            // 子类没有覆盖重写，就是父类 10
            // 子类如果覆盖重写，就是子类 20
            obj.showNum();
        }
    }

*  父类

package Multi.Demo02;
    
    public class Fu { 
        int num = 10;
    
        public void showNum() { 
            System.out.println(num);
        }
    
        public void method() { 
            System.out.println("父类方法");
        }
    
        public void methodFu() { 
            System.out.println("父类特有方法");
        }
    }

*  子类

package Multi.Demo02;
    
    public class Zi extends Fu{ 
        int num = 20;
    
        // 子类覆盖重写
        @Override
        public void showNum() { 
            System.out.println(num);
        }
    
        @Override
        public void method() { 
            System.out.println("子类方法");
        }
    
        public void methodZi() { 
            System.out.println("子类特有方法");
        }
    }

## 使用多态的好处 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 10]

## 对象的向上、向下转型（instanceof类型判断） ##

*  代码运行

package obj.Animal.demo01.demo1.animal;
    
    /* * 向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端： * 对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。 * */
    public class Demo01Main { 
        public static void main(String[] args) { 
            // 对象的向上转型，就是：父类引用指向子类对象。
            Animal animal = new Cat();
            animal.eat(); // 猫吃鱼
    
            // 错误写法 【对象一旦向上转型为父类，那么就无法调用子类原本特有的内容】
            // animal.catchMouse();
    
            // 向下转型，进行 "还原" 动作
            Cat cat = (Cat) animal;
            cat.catchMouse(); // 猫抓老鼠
    
            /* * 下面是错误的向下转型 * 本来new的时候是一只猫，现在非要当做狗 * 错误写法! 编译不会报错，但是运行会出现异常：java.lang.ClassCastException 类转换异常 * */
            // Dog dog = (Dog) animal;
        }
    }

*  动物类

package obj.Animal.demo01.demo1.animal;
    
    // 抽象方法所在的类，一定是抽象类
    public abstract class Animal { 
        public abstract void eat();
    }

*  猫类

package obj.Animal.demo01.demo1.animal;
    
    // 猫类
    public class Cat extends Animal{ 
        @Override
        public void eat() { 
            System.out.println("猫吃鱼");
        }
        // 子类特有方法
        public void catchMouse() { 
            System.out.println("猫抓老鼠");
        }
    }

*  狗类

package obj.Animal.demo01.demo1.animal;
    
    // 狗类
    public class Dog extends Animal{ 
        @Override
        public void eat() { 
            System.out.println("狗吃骨头");
        }
    
        public void watchHouse() { 
            System.out.println("狗看家");
        }
    }

*  用instanceof关键字进行类型判断

package obj.Animal.demo01.demo1.animal;
    
    /* * 如何才能知道一个父类引用的对象，本来是什么子类？ * 格式： 对象 instanceof 类名称 * 这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例 * * */
    public class Demo02Instanceof { 
        public static void main(String[] args) { 
            Animal animal = new Cat(); // 本来是一只猫
            animal.eat(); // 猫吃鱼
    
            /* * 如果希望调用子类特有方法，需要向下转型 * 判断一下父类引用 animal 本来是不是Dog * */
            if (animal instanceof  Dog) { 
                Dog dog = (Dog) animal;
                dog.watchHouse();
            }
            // 判断一下 animal 本来是不是Cat
            if (animal instanceof Cat) { 
                Cat cat = (Cat) animal;
                cat.catchMouse(); // 猫抓老鼠
            }
    		
            // 给我一个动物
            giveMeAPet(new Dog());
        }
    
        public static void giveMeAPet(Animal animal) { 
            if (animal instanceof Dog) { 
                Dog dog = (Dog) animal;
                dog.watchHouse(); // 狗看家
            }
            if (animal instanceof Cat) { 
                Cat cat = (Cat) animal;
                cat.catchMouse();
            }
        }
    }

## 多态综合案例：笔记本电脑接口 ##

> 接口的基本使用–对象的上下转型–使用接口作为方法的参数

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 11]

package obj.Animal.demo01.demo1.USB;
    
    public class DemoMain { 
        public static void main(String[] args) { 
            // 首先创建一个笔记本电脑
            Computer computer = new Computer();
            computer.powerOn();
    
            // 准备一个鼠标，供电脑使用：首先进行向上转型
            USB usbMouse = new Mouse();
            // 参数是USB类型，我正好传递进去的就是USB鼠标
            computer.useDevice(usbMouse);
    
            // 创建一个USB键盘
            Keyboard keyboard = new Keyboard(); // 没有使用多态写法
            // 方法参数是USB类型，传递进去的是实现类对象
            computer.useDevice(keyboard); // 正确写法，发生了向上转型
            // 使用子类对象，匿名对象，也可以
            computer.useDevice(new Keyboard()); // 正确写法
    
            computer.powerOff();
            System.out.println("============");
    
            method(10.0); // 正确写法：double ---> double
            method(20); // 正确写法：int ---> double
            int a = 30;
            method(a); // 正确写法：int ---> double
            computer.powerOff();
        }
    
        public static void method(double num) { 
            System.out.println(num);
        }
    }

*  电脑

package obj.Animal.demo01.demo1.USB;
    
    // 电脑
    public class Computer { 
    
        public void powerOn() { 
            System.out.println("笔记本电脑开机");
        }
    
        public void powerOff() { 
            System.out.println("笔记本电脑关机");
        }
    
        // 使用USB设备的方法，使用接口作为方法的参数
        public void useDevice(USB usb) { 
            usb.open(); // 打开设备
            if (usb instanceof Mouse) {  // 一定要先判断
                Mouse mouse = (Mouse) usb; // 向下转型
                mouse.click();
            } else if (usb instanceof Keyboard) {  // 先判断
                Keyboard keyboard = (Keyboard) usb; // 向下转型
                keyboard.type();
            }
            usb.close(); // 关闭设备
        }
    }

*  usb 抽象类

package obj.Animal.demo01.demo1.USB;
    
    // usb 抽象类
    public abstract class USB { 
    
        public abstract void open(); // 打开设备
        public abstract void close(); // 关闭设备
    }

*  鼠标

package obj.Animal.demo01.demo1.USB;
    
    // 鼠标就是一个USB设备
    public class Mouse extends USB { 
    
        @Override
        public void open() { 
            System.out.println("打开鼠标");
        }
    
        @Override
        public void close() { 
            System.out.println("关闭鼠标");
        }
    
        public void click() { 
            System.out.println("鼠标点击");
        }
    }

*  键盘

package obj.Animal.demo01.demo1.USB;
    
    // 键盘就是一个USB设备
    public class Keyboard extends USB { 
    
        @Override
        public void open() { 
            System.out.println("打开键盘");
        }
    
        @Override
        public void close() { 
            System.out.println("关闭键盘");
        }
    
        public void type() { 
            System.out.println("键盘输入");
        }
    }

# final关键字 #

*  final关键字-修饰类

package obj.Animal.demo01.demo1.Final;
    
    /* * 当final关键字用来修饰一个类的时候，格式： * public final class 类名称 { 方法体 } * * 含义：当前这个类不能有任何的子类。（太监类） * 注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子） * */
    public final class MyClass { 
        public void method() { 
            System.out.println("方法执行");
        }
    }

*  父类：final关键字-修饰成员方法

package obj.Animal.demo01.demo1.Final;
    
    /* * 当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。 * 格式： 修饰符 final 返回值类型 方法名称(参数列表) { 方法体 } * * 注意事项： * 1.对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。 * */
    public abstract class Fu { 
        public final void method() { 
            System.out.println("父类方法执行");
        }
    
        public abstract /*final*/ void methodAbs();
    }

*  子类

package obj.Animal.demo01.demo1.Final;
    
    public class Zi extends Fu{ 
        @Override
        public void methodAbs() { 
    
        }
    
        // 错误写法：不能覆盖重写父类当中final的方法
    // @Override
    // public void method() { 
    // System.out.println("子类覆盖重写父类的方法");
    // }
    }

*  final关键字-修饰局部变量

package obj.Animal.demo01.demo1.Final;
    /* * final关键字代表最终、不可改变的。 * * 常见四种用法： * 1.可以用来修饰一个类 * 2.可以用来修饰一个方法 * 3.还可以用来修饰一个局部变量 * 4.还可以用来修饰一个成员变量 * */
    public class Demo01Final { 
        public static void main(String[] args) { 
            int num1 = 10;
            System.out.println(num1); // 10
    
            num1 = 20;
            System.out.println(num1); // 20
    
            /* * 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。 * 一次赋值，终生不变 * */
            final int num2 = 200;
            System.out.println(num2); // 200
    
    // num2 = 250; // 错误写法：不能改变
    // num2 = 200; // 错误写法：即使赋值为原值200，也不可以!!!
    
            // 正确写法：只要保证有唯一一次赋值即可
            final int num3;
            num3 = 30;
    
            /* * 对于基本类型来说，不可变说的是变量当中的数据不可改变。 * 对于引用类型来说，不可变说的是变量当中的地址值不可改变。 * */
            Student stu1 = new Student("赵丽颖");
            System.out.println(stu1); // obj.Animal.demo01.demo1.Final.Student@1540e19d
            System.out.println(stu1.getName()); // 赵丽颖
            stu1 = new Student("霍建华");
            System.out.println(stu1); // obj.Animal.demo01.demo1.Final.Student@677327b6
            System.out.println(stu1.getName()); // 霍建华
            System.out.println("=======================");
    
            final Student stu2 = new Student("刘诗诗");
            // stu2 = new Student("吴奇隆"); // 错误写法! final的引用类型变量，其中的地址不可改变
    
            System.out.println(stu2.getName()); // 刘诗诗
            stu2.setName("诗爷");
            System.out.println(stu2.getName()); // 诗爷
        }
    }

*  Person类：final关键字-修饰成员变量

package obj.Animal.demo01.demo1.Final;
    
    /* * 对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。 * 1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。 * 2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一 * 3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。 * */
    public class Person { 
    
        private final String name;
    
        // 无参构造
        public Person() { 
            name = "刘诗诗";
        }
    
        // 有参构造
        public Person(String name) { 
            this.name = name;
        }
    
        // Getter/Setter方法
        public String getName() { 
            return name;
        }
    
    // public void setName(String name) { 
    // this.name = name;
    // }
    }

*  学生类

package obj.Animal.demo01.demo1.Final;
    
    // 学生类
    public class Student { 
        private String name;
    
        // 无参构造
        public Student() { 
    
        }
        // 有参构造
        public Student(String name) { 
            this.name = name;
        }
    
        // Getter/Setter方法
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    }

# 四种权限修饰符 #

Java中有四种权限修饰符： (权限：从大到小)
    public > protected > (default) > private
    
    注意：(default) 并不是关键字"default"，而是根本不写。

<table> 
 <thead> 
  <tr> 
   <th>-</th> 
   <th align="center">public</th> 
   <th align="center">protected</th> 
   <th align="center">(default)</th> 
   <th align="center">private</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>同一个类（我自己）</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
  </tr> 
  <tr> 
   <td>同一个包（我邻居）</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
   <td align="center">×</td> 
  </tr> 
  <tr> 
   <td>不同包子类（我儿子）</td> 
   <td align="center">√</td> 
   <td align="center">√</td> 
   <td align="center">×</td> 
   <td align="center">×</td> 
  </tr> 
  <tr> 
   <td>不同包非子类（陌生人）</td> 
   <td align="center">√</td> 
   <td align="center">×</td> 
   <td align="center">×</td> 
   <td align="center">×</td> 
  </tr> 
 </tbody> 
</table>

## 成员内部类的定义和使用 ##

package wd01.demo01;
    /* * 如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。 * 例如：汽车和发动机的关系。 * * 分类： * 1.成员内部类 * 2.局部内部类（包含匿名内部类） * * 成员内部类的定义格式： * 修饰符 class 外部类名称 { * 修饰符 class 内部类名称 { * // ... * } * // ... * } * * 注意：内用外，随意访问；外用内，需要内部类对象。 * ===================== * 如何使用成员内部类？有两种方式： * 1.间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。 * 2.直接方式： * 类名称 对象名 = new 类名称(); * 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称(); * */
    public class Demo01InnerClass { 
        public static void main(String[] args) { 
            Body body = new Body(); // 外部类的对象
            // 通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
            body.methodBody();
            System.out.println("========");
            // 按照公式写：
            Body.Heart heart = new Body().new Heart();
            heart.beat();
        }
    }

package wd01.demo01;
    
    public class Body { 
    
        // 外部类的成员变量
        private String name;
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public class Heart { 
            // 内部类的方法
            public void beat() { 
                System.out.println("心脏跳动");
                System.out.println("我叫：" + name); // 正确写法
            }
        }
        // 外部类的方法
        public void methodBody() { 
            System.out.println("外部类的方法");
            // 在外部类的方法里面，创建内部类对象
            Heart heart = new Heart();
            heart.beat();
        }
    }

## 内部类的同名变量访问 ##

package wd01.demo01;
    
    public class Demo02InnerClass { 
        public static void main(String[] args) { 
            // 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
            Outer.Inner obj = new Outer().new Inner();
            obj.methodInner();
        }
    }

package wd01.demo01;
    // 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
    public class Outer { 
    
        int num = 10; // 外部类的成员变量
    
        public class Inner { 
             int num = 20; // 内部类的成员变量
             public void methodInner() { 
                 int num = 30; // 内部类方法的局部变量
                 System.out.println(num); // 局部变量，就近原则 30
                 System.out.println(this.num); // 内部类的成员变量 20
                 System.out.println(Outer.this.num); // 外部类的成员变量 10
             }
        }
    }

## 局部内部类的final问题 ##

package wd01.demo01.Outes;
    /* * 局部内部类：如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】 * * 备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。 * * 原因： * 1.new出来的对象在堆内存当中。 * 2.局部变量是跟着方法走的，在栈内存当中。 * 3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。 * 4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。 * */
    public class MyOuter { 
        public void methodOuter() { 
            final int num = 10; // 所在方法的局部变量
            class MyInner { 
                public void methodInner() { 
                    System.out.println(num);
                }
            }
        }
    }

## 匿名内部类【重点】 ##

package wd01.demo01.niName;
    /* * 如果接口的实现类（或者是父类的子类）只需要使用唯一的一次。 * 那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】 * * 匿名内部类的定义格式： * 接口名称 对象名 = new 接口名称() { * // 覆盖重写所有抽象方法 * } * * 对格式 "new 接口名称() { ... }"进行解析： * 1.new 代表创建对象的动作 * 2.接口名称就是匿名内部类需要实现哪个接口 * 3.{ ... }这才是匿名内部类的内容 * * 另外还有注意几点问题： * 1.匿名内部类，在创建对象的时候，只能使用唯一一次。 * 如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。 * 2.匿名对象，在【调用方法】的时候，只能调用唯一一次。 * 如果希望同一个对象，调用多次方法，那么必须给对象起个名字。 * 3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】 * 强调：匿名内部类和匿名对象不是一回事儿!!! * */
    public class DemoMain { 
        public static void main(String[] args) { 
    // MyInterfaceImpl impl = new MyInterfaceImpl();
    // impl.method();
    
            // 使用匿名内部类
            MyInterface objA = new MyInterface() { 
                @Override
                public void method() { 
                    System.out.println("匿名内部类实现了方法");
                }
            };
            objA.method();
            System.out.println("===========");
    
            // 使用了匿名内部类，而且省略了对象名称，也是匿名对象
            new MyInterface() { 
                @Override
                public void method() { 
                    System.out.println("匿名内部类实现了方法");
                }
            }.method();
        }
    }

package wd01.demo01.niName;
    
    public interface MyInterface { 
        public abstract void method(); // 抽象方法
    }

## 类作为成员变量类型 ##

package wd01.demo01.Heros;
    
    public class DemoMain { 
        public static void main(String[] args) { 
            // 创建一个英雄角色
            Hero hero = new Hero();
            // 为英雄起一个名字，并且设置年龄
            hero.setName("盖伦");
            hero.setAge(20);
    
            // 创建一个武器对象
            Weapon weapon = new Weapon("圣剑");
            // 为英雄配备武器
            hero.setWeapon(weapon);
            // 攻击
            hero.attack();
        }
    }

*  英雄

package wd01.demo01.Heros;
    /* * 游戏当中的英雄角色类 * */
    public class Hero { 
        private String name; // 英雄名字
        private int age; // 英雄的年龄
        private Weapon weapon; // 英雄的武器
    
        public Hero() { 
    
        }
    
        public Hero(String name, int age, Weapon weapon) { 
            this.name = name;
            this.age = age;
            this.weapon = weapon;
        }
        // 攻击敌人
        public void attack() { 
            System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方");
        }
    
        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 Weapon getWeapon() { 
            return weapon;
        }
    
        public void setWeapon(Weapon weapon) { 
            this.weapon = weapon;
        }
    }

*  武器

package wd01.demo01.Heros;
    
    public class Weapon { 
        private String code; // 武器的代号
    
        public Weapon() { 
        }
    
        public Weapon(String code) { 
            this.code = code;
        }
    
        public String getCode() { 
            return code;
        }
    
        public void setCode(String code) { 
            this.code = code;
        }
    }

## 接口作为成员变量类型 ##

package wd01.demo01.implement;
    
    public class DemoGame { 
        public static void main(String[] args) { 
            Hero hero = new Hero();
            hero.setName("艾希"); // 设置英雄的名称
    
            // 设置英雄技能--使用单独定义的实现类
            hero.setSkill(new SkillImpl());
    
            // 还可以改成使用匿名内部类
            Skill skill = new Skill() { 
                @Override
                public void use() { 
                    System.out.println("呯呯呯");
                }
            };
            hero.setSkill(skill);
    
            // 进一步简化，同时使用匿名内部类和匿名对象
            hero.setSkill(new Skill() { 
                @Override
                public void use() { 
                    System.out.println("喵喵喵~");
                }
            });
            // 攻击敌人
            hero.attack();
        }
    }

package wd01.demo01.implement;
    
    public class Hero { 
        private String name; // 英雄的名称
        private Skill skill; // 英雄的技能
    
        public Hero() { 
        }
    
        public Hero(String name, Skill skill) { 
            this.name = name;
            this.skill = skill;
        }
    
        public void attack() { 
            System.out.println("我叫" + name + "开始释放技能");
            skill.use(); // 调用接口中的抽象方法
            System.out.println("释放技能完成");
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Skill getSkill() { 
            return skill;
        }
    
        public void setSkill(Skill skill) { 
            this.skill = skill;
        }
    }

package wd01.demo01.implement;
    
    public class SkillImpl implements Skill{ 
    
        @Override
        public void use() { 
            System.out.println("咚咚咚~");
        }
    }

package wd01.demo01.implement;
    
    public interface Skill { 
        void use(); // 释放技能的抽象方法
    }

## 接口作为方法的参数和返回值 ##

package wd01.demo01.implement;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /* * java.util.list 正是ArrayList所实现的接口 * */
    public class DemoInterface { 
        public static void main(String[] args) { 
            // 左边是接口名称，右边是实现类名称，这就是多态写法
            List<String> list = new ArrayList<>();
    
            List<String> result = addNames(list);
            for (int i = 0; i < result.size(); i++) { 
                System.out.println(result.get(i));
            }
        }
    
        public static List<String> addNames(List<String> list) { 
            list.add("迪丽热巴");
            list.add("古力娜扎");
            list.add("马尔扎哈");
            list.add("沙扬娜拉");
            return list;
        }
        
        public void setName(String name) { 
            this.name = name;
        }
    
        public int getAge() { 
            return age;
        }
    
        public void setAge(int age) { 
            this.age = age;
        }
    
        public Weapon getWeapon() { 
            return weapon;
        }
    
        public void setWeapon(Weapon weapon) { 
            this.weapon = weapon;
        }
    }

*  武器

## 接口作为成员变量类型 ##

package wd01.demo01.implement;
    
    public class SkillImpl implements Skill{ 
    
        @Override
        public void use() { 
            System.out.println("咚咚咚~");
        }
    }

package wd01.demo01.implement;
    
    public interface Skill { 
        void use(); // 释放技能的抽象方法
    }

## 接口作为方法的参数和返回值 ##

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/ae96e226d6c34abfada83573c154ec76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/68a130152e49491cabb27949676ea6eb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/9e99b454326242afa0e7cbf5b235d57b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/105295d907a14410adcd30afef99bc96.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/713311cb26174e56a75fd3dbcde28c1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/a8e81a437b6c4e7aac3e672f77357fbc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/cab4c0bf8e184477a29d666010a44e66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/90426748e28747e0a5b21c71ed47c006.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/4a7d73f3019d48a8b42505163cb55fe1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/874a223922c446bb93036e7e65f7882c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/e0da623515434f82a4d151cf43e8b146.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDY2NjY0NA_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221123/d8738f0535af4e0e9592b1e93fdfc696.png