面向对象（多态）（final关键字）（抽象类）（接口）

小咪咪 2024-03-23 22:20 12阅读 0赞

#### 多态 ####

多态是在继承或实现条件下，表现为对象多态，行为多态。

People p1 = new Student();
    
    p1.run();
    
    People p2 = new Teacher();
    
    p2.run();

**多态的前提：**

1.存在继承或实现关系；

2.存在父类引用子类对象；

3.存在方法的重写；

注意：Java中属性没有多态，多态只存在于对象，和行为；

**多态的好处：**

1.解耦合，便于扩展和维护；

2.定义方法时，可以将父类作为形参，可以接受子类的一切对象，扩展性更强，更便利；

**在多态下不能使用子类特有的方法：**

**自动类型转换：父类 变量名 = new 子类（）；**

**强制类型转换：子类 变量名 = （子类）父类变量；**

强制类型转换的一个注意事项 存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。 运行时，如果发现对象的真实类型与强转后的类型不同，就会报类型转换异常（ClassCastException）的错误出来。使用instanceof关键字，判断当前对象的真实类型，再进行强转。

1、使用多态有什么好处？存在什么问题？

可以解耦合，扩展性更强；使用父类类型的变量作为方法的形参时，可以接收一切子类对象。 多态下不能直接调用子类的独有方法。

2、类型转换有几种形式？能解决什么问题？

自动类型转换、强制类型转换。 可以把对象转换成其真正的类型，从而解决了多态下不能调用子类独有方法的问题。

3、强制类型转换需要注意什么？

存在继承/实现时，就可以进行强制类型转换，编译阶段不会报错。 但是，运行时，如果发现对象的真实类型与强转后的类型不同会报错（ClassCastException）。

4、强制类型转换前？Java建议我们做什么事情？

使用instanceof判断当前对象的真实类型：对象 instanceof 类型 。

#### final ####

*   final 关键字是最终的意思，可以修饰（类、方法、变量） 
 *  修饰类：该类被称为最终类，特点是不能被继承了。
 *  修饰方法：该方法被称为最终方法，特点是不能被重写了。 
 *  修饰变量：该变量只能被赋值一次。

final修饰变量的注意

final修饰基本类型的变量，变量存储的数据不能被改变。

final修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的。

#### 常量： ####

*  使用了static ，final修饰的成员变量被称为常量；
 *  常量被用作于记录系统配置，常量名要大写，多个单词要用下划线连接；

public class Constant {  
    
    public static final String URL_ID  = “Http://www.aliyun.com";
    
    }

**常量记录系统配置的好处、执行原理：**

*  代码可读性更好，可维护性也更好。
 *  程序编译后，常量会被“宏替换”：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的。

#### 抽象类 ####

Java中用abstract关键词修饰的类叫抽象类，修饰方法叫抽象方法；

public abstract class A {
     // 抽象方法：必须abstract修饰，只有方法签名，不能有方法体。
     public abstract void test();
    }

**特点：**

*  抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类 
 *  抽象类中可以声明成员变量、成员方法、构造器 
 *  抽象类最主要的特点：抽象类不能被实例化，它仅作为一种特殊的类，让子类继承并实现 
 *  抽象类的子类，要么重写所有抽象方法，要么将自己也声明为抽象类

**抽象类的应用场景：**

一种是：用抽象类，我们可以把子类中相同的代码，包括方法声明都抽上来，这样能更好的支持多态，以提高代码的灵活性。

另一种是：反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去继承实现，以方便系统的扩展。

#### 模板设计模式： ####

**模板方法模式解决了多个子类中有相同代码的问题。具体实现步骤如下**

**第1步：定义一个抽象类，把子类中相同的代码写成一个模板方法。  
第2步：把模板方法中不能确定的代码写成抽象方法，并在模板方法中调用。  
第3步：子类继承抽象类，只需要父类抽象方法就可以了。**

// 模板方法设计模式
    public abstract class C {
        // 模板方法
        public final void sing(){
            System.out.println("唱一首你喜欢的歌：");
    
            doSing();
    
            System.out.println("唱完了!");
        }
    
        public abstract void doSing();
    }

然后，写一个A类继承C类，复写doSing()方法，代码如下

public class A extends C{
        @Override
        public void doSing() {
            System.out.println("我是一只小小小小鸟，想要飞就能飞的高~~~");
        }
    }

接着，再写一个B类继承C类，也复写doSing()方法，代码如下

public class B extends C{
        @Override
        public void doSing() {
            System.out.println("我们一起学猫叫，喵喵喵喵喵喵喵~~");
        }
    }

最后，再写一个测试类Test

public class Test {
        public static void main(String[] args) {
            // 目标：搞清楚模板方法设计模式能解决什么问题，以及怎么写。
            B b = new B();
            b.sing();
        }
    }

#### 接口： ####

用特殊关键字interface定义的特殊结构；

public interface 接口名{
    
        成员变量（常量）
    
        成员方法（抽象方法）
    
    }

注意：接口不能创建对象，接口是用来被实现的；

修饰符 class 实现类 implement 接口1，接口2，....{
    
    
    }

一个类可以实现多个接口，必须重写接口中的全部方法，不然实现类需要定义成抽象类；

**接口的好处：**

**1.弥补了单继承的不足，一个类可以同时实现多个接口；**

**2.面向接口编程，可以灵活的切换各种业务；**

#### **接口案例：** ####

设计一个班级学生的信息管理模块：学生的数据有：姓名、性别、成绩 功能1：要求打印出全班学生的信息； 功能2：要求打印出全班学生的平均成绩。 ------------------------------------------------------------------------------------------------------------------------ 注意！以上功能的业务实现是有多套方案的，比如： 第1套方案：能打印出班级全部学生的信息；能打印班级全部学生的平均分。 第2套方案：能打印出班级全部学生的信息（包含男女人数）；能打印班级全部学生的平均分（要求是去掉最高分、最低分）。 要求：系统可以支持灵活的切换这些实现方案。

1.首先我们写一个学生类，用来描述学生的相关信息；

public class Student {
        private String name;
        private char sex;
        private double score;
    
        public Student() {
        }
    
        public Student(String name, char sex, double score) {
            this.name = name;
            this.sex = sex;
            this.score = score;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public char getSex() {
            return sex;
        }
    
        public void setSex(char sex) {
            this.sex = sex;
        }
    
        public double getScore() {
            return score;
        }
    
        public void setScore(double score) {
            this.score = score;
        }
    }

2.接着，写一个StudentOperator接口，表示学生信息管理系统的两个功能。

public interface StudentOperator {
        void printAllInfo(ArrayList<Student> students);
        void printAverageScore(ArrayList<Student> students);
    }

3.然后，写一个StudentOperator接口的实现类StudentOperatorImpl1，采用第1套方案对业务进行实现。

public class StudentOperatorImpl1 implements StudentOperator{
        @Override
        public void printAllInfo(ArrayList<Student> students) {
            System.out.println("----------全班全部学生信息如下--------------");
            for (int i = 0; i < students.size(); i++) {
                Student s = students.get(i);
                System.out.println("姓名：" + s.getName() + ", 性别：" + s.getSex() + ", 成绩：" + s.getScore());
            }
            System.out.println("-----------------------------------------");
        }
    
        @Override
        public void printAverageScore(ArrayList<Student> students) {
            double allScore = 0.0;
            for (int i = 0; i < students.size(); i++) {
                Student s = students.get(i);
                allScore += s.getScore();
            }
            System.out.println("平均分：" + (allScore) / students.size());
        }
    }

4.接着，再写一个StudentOperator接口的实现类StudentOperatorImpl2，采用第2套方案对业务进行实现。

public class StudentOperatorImpl2 implements StudentOperator{
        @Override
        public void printAllInfo(ArrayList<Student> students) {
            System.out.println("----------全班全部学生信息如下--------------");
            int count1 = 0;
            int count2 = 0;
            for (int i = 0; i < students.size(); i++) {
                Student s = students.get(i);
                System.out.println("姓名：" + s.getName() + ", 性别：" + s.getSex() + ", 成绩：" + s.getScore());
                if(s.getSex() == '男'){
                    count1++;
                }else {
                    count2 ++;
                }
            }
            System.out.println("男生人数是：" + count1  + ", 女士人数是：" + count2);
            System.out.println("班级总人数是：" + students.size());
            System.out.println("-----------------------------------------");
        }
    
        @Override
        public void printAverageScore(ArrayList<Student> students) {
            double allScore = 0.0;
            double max = students.get(0).getScore();
            double min = students.get(0).getScore();
            for (int i = 0; i < students.size(); i++) {
                Student s = students.get(i);
                if(s.getScore() > max) max = s.getScore();
                if(s.getScore() < min) min = s.getScore();
                allScore += s.getScore();
            }
            System.out.println("学生的最高分是：" + max);
            System.out.println("学生的最低分是：" + min);
            System.out.println("平均分：" + (allScore - max - min) / (students.size() - 2));
        }

5.再写一个班级管理类ClassManager，在班级管理类中使用StudentOperator的实现类StudentOperatorImpl1对学生进行操作

public class ClassManager {
        private ArrayList<Student> students = new ArrayList<>();
        private StudentOperator studentOperator = new StudentOperatorImpl1();
    
        public ClassManager(){
            students.add(new Student("迪丽热巴", '女', 99));
            students.add(new Student("古力娜扎", '女', 100));
            students.add(new Student("马尔扎哈", '男', 80));
            students.add(new Student("卡尔扎巴", '男', 60));
        }
    
        // 打印全班全部学生的信息
        public void printInfo(){
            studentOperator.printAllInfo(students);
        }
    
        // 打印全班全部学生的平均分
        public void printScore(){
            studentOperator.printAverageScore(students);
        }
    }

6.最后，再写一个测试类Test，在测试类中使用ClassMananger完成班级学生信息的管理。

public class Test {
        public static void main(String[] args) {
            // 目标：完成班级学生信息管理的案例。
            ClassManager clazz = new ClassManager();
            clazz.printInfo();
            clazz.printScore();
        }
    }

#### 接口JDK8新特性 ####

public interface A {
        /**
         * 1、默认方法：必须使用default修饰，默认会被public修饰
         * 实例方法：对象的方法，必须使用实现类的对象来访问。
         */
        default void test1(){
            System.out.println("===默认方法==");
            test2();
        }
    
        /**
         * 2、私有方法：必须使用private修饰。(JDK 9开始才支持的)
         *   实例方法：对象的方法。
         */
        private void test2(){
            System.out.println("===私有方法==");
        }
    
        /**
         * 3、静态方法：必须使用static修饰，默认会被public修饰
         */
         static void test3(){
            System.out.println("==静态方法==");
         }
    
         void test4();
         void test5();
         default void test6(){
    
         }

接下来我们写一个B类，实现A接口。B类作为A接口的实现类，只需要重写抽象方法就可以了，对于默认方法不需要子类重写。代码如下

public class B implements A{
        @Override
        public void test4() {
    
        }
    
        @Override
        public void test5() {
    
        }
    }

最后，写一个测试类，观察接口中的三种方法，是如何调用的

public class Test {
        public static void main(String[] args) {
            // 目标：掌握接口新增的三种方法形式
            B b = new B();
            b.test1();	//默认方法使用对象调用
            // b.test2();	//A接口中的私有方法，B类调用不了
            A.test3();	//静态方法，使用接口名调用
        }
    }

**一个接口可以继承多个接口，实现类必须重写父接口的所有方法：**

public class Test {
        public static void main(String[] args) {
            // 目标：理解接口的多继承。
        }
    }
    
    interface A{
        void test1();
    }
    interface B{
        void test2();
    }
    interface C{}
    
    //比如：D接口继承C、B、A
    interface D extends C, B, A{
    
    }
    
    //E类在实现D接口时，必须重写D接口、以及其父类中的所有抽象方法。
    class E implements D{
        @Override
        public void test1() {
    
        }
    
        @Override
        public void test2() {
    
        }
    }

**注意：**

**1.一个接口继承多个接口，如果多个接口中存在相同的方法声明，则此时不支持多继承  
2.一个类实现多个接口，如果多个接口中存在相同的方法声明，则此时不支持多实现  
3.一个类继承了父类，又同时实现了接口，父类中和接口中有同名的默认方法，实现类会有限使用父类的方法  
4.一个类实现类多个接口，多个接口中有同名的默认方法，则这个类必须重写该方法。**