Java 三大特征：封装、继承（方法覆盖,this,super）和多态

你的名字 2021-12-11 10:39 244阅读 0赞

面向对象的三大特征：封装(Encapsulation)、继承(Inheritance)和多态(Polymorphism)。

### **一、封装（Encapsulation）** ###

封装：将类的某些信息隐藏在类的内部，不允许外部程序访问，而是通过该类提供的公共方法来实现对隐藏信息的操作和访问。

**封装的目的是**：增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。

**封装的基本要求是**：把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写toString方法，但这不是必须的。

**1、四大访问权限控制修饰符**：这四个修饰符都可以修饰变量和方法

1）private（类访问权限）：使用 private 修饰的成员(字段,方法,构造器),就只能在当前类中范围.

2）什么都不写（缺省的/包访问权限）：此时只有在同一个包中,才可以访问的到,若不在同包中,不能访问.

3）protected（子类访问权限）：即使父类和子类不在同一个包中,也可以访问.

4）public（公共访问权限）：在任何地方都可以访问到.

![20190708230020472.png][]

public class Student {
        private String name;
        private int 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 static void main(String[] args) {
            Student stu = new Student();
            stu.setName("李四");
            stu.setAge(17);
            System.out.println(stu.getName() + "--" + stu.getAge()); //李四--17
        }
    }

### **2、继承（Inheritance）** ###

继承是类与类的关系，在Java中类的继承，只允许单继承，不支持多继承。 一个类，只能有一个直接的父类，但是允许多重继承.。

在Java中,即使A类没有显示的去继承B类,此时A类的父类是Object.推论:任何类(除了Object),都有一个父类.

继承是一种“（is-a）”的关系，就是从一般到特殊的过程。 构造方法不能被继承,因为构造方法的名称与类名相同。

**继承的好处**：继承是面向对象实现软件复用的重要手段，即子类对父类代码的复用

**子类可以继承到父类哪些成员:    **

1）若父类成员使用public或者protected修饰,子类可以继承.

2）若父类成员使用包访问权限(不写):

若子类和父类在同包中,可以继承.

若子类和父类不在同包中,则不能继承.

3）若父类成员使用private修饰,子类不能继承.

4）父类的构造器,子类也继承不到.

**继承的语法规则**：修饰符 class  子类  extends  父类

public class Human {
    
        public void sleep(){
            System.out.println("睡觉。。。");
        }
    }
    
    public class Student extends Human{
        private String name;
        private int age;
        public static void main(String[] args) {
            Student stu = new Student();
            stu.sleep(); // 睡觉。。。
        }
    }

### 方法覆盖(Override) ###

当父类中的某一行为特征不适应子类的自身特征时，可采用方法的覆盖，即子类包含与父类同名方法，并重新编写方法体。

方法覆盖(Override)：存在继承关系,强调的是父类和子类的方法.

**方法覆盖遵循原则："一同两小一大".**

一同：方法的名称要相同.

两小：

1）子类方法的返回类型应该小于等于父类方法的返回类型.

子类方法的返回类型要么等于父类方法的返回类型,要么是父类方法返回类型的子类.

2)）子类方法声明抛出的异常应该小于等于父类方法抛出的异常

一大:子类方法的访问修饰符,必须大于等于父类方法的访问修饰符.

注意：方法覆盖(复写,覆写),只能对方法有效,类,构造器,字段没有覆盖的概念.

判断方法是否是覆盖的准则:

在Java5开始,其中有一个注解:@Override.用于帖子子类方法上,用于判断当前方法是否是覆盖方法.

**子类的创建过程:**

1）创建子类对象时,会调用子类的构造器,而在调用子类构造器之前,会先调用父类的构造器.

2）先对父类做初始化,再对子类做初始化.

public class Student extends Human{
        private String name;
        private int age;
    
        @Override
        public void sleep() {
            System.out.println("student sleep...");
        }
    
        public static void main(String[] args) {
            Student stu = new Student();
            stu.sleep(); // student sleep...
        }
    }

### this关键字与super关键字区别 ###

this关键字：代表当前对象，哪一个对象调用了this所在的方法,该方法中的this就指那个对象

super关键字：代表当前对象的父类对象

**this关键字的应用场景:**

1）解决成员变量和局部变量之间的二义性,必须使用;(setter方法)

2）同一个类中多个实例方法间互调。

3）将当前对象作为参数传递给另一个方法;

4）将当前对象作为方法的返回值(链式方法编程);

5）构造器重载的互调，this(\[参数\])必须写在构造方法第一行;this();//表示调用无参数构造器.

**super关键字的应用场景:**

1）在子类方法中,调用父类被覆盖掉的方法,如:super.sleep();不能省略.

2）在子类方法中,返回父类被隐藏掉的成员变量. (极少使用)

3）在子类的构造器中,调用父类的构造器:super(\[参数\]);

### 隐藏/遮蔽：把之前的给挡住了，有三种情况: ###

1）局部变量和成员变量同名,局部变量隐藏成员变量,使用this关键字解决:

2）在满足继承条件之下(少见):

子类存在和父类同名的成员变量,子类变量隐藏了父类变量,使用super关键字解决.

3）在满足继承条件之下(少见):

子类存在和父类相同的静态方法.-->静态方法不存在覆盖.

### **3、多态（Polymorphism）** ###

多态：子类对象可以直接赋给父类变量，但运行时依然表现出子类的行为特征。

**多态的作用:**

当把不同的子类对象都当作父类类型来看，可以屏蔽不同子类对象之间的实现差异，从而写出通用的代码达到通用编程，以适应需求的不断变化。

**多态的前提:**

A：要有继承/实现关系

B：要有方法覆盖/重写

C：要有父类引用指向子类的对象。 父 f = new 子();

**多态中成员访问的特点分别是什么?**

多态实现的机制是: 动态绑定机制: 属性看声明(左边),方法看对象(右边).

成员变量:   编译看左边(父类)，运行看左边(父类)

成员方法:   编译看左边(父类)，运行看右边(子类)。

静态方法：编译看左边(父类)，运行看左边(父类)。静态方法属于隐藏,不属于方法覆盖

只有非静态的成员方法,编译看左边,运行看右边

**引用类型转换:**

自动类型转换：把子类对象赋给父类变量(多态形式).

强制类型转换：Student stu = (Student) human;

**instanceof 运算符**：判断某一对象是否是某一种类型

语法格式：boolean result = 对象 instanceof 类名/类型;

public class Student extends Human{
        private String name;
        private int age;
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public void sleep() {
            super.sleep();
            System.out.println("student sleep...");
        }
    
        public static void main(String[] args) {
            Human human = new Student();
            human.sleep();
            boolean result = human instanceof Student;
            if(result){
                Student stu = (Student) human;
                System.out.println(true);
            }else{
                System.out.println(false);
            }
            // 睡觉。。。
            // student sleep...
            // true
        }
    }

ends ~

[20190708230020472.png]: /images/20211211/e016d0ae51af48e38c23745e37cdc395.png