面向对象编程三大特性—封装、继承和多态

Dear 丶 2024-04-08 10:28 28阅读 0赞

**目录**

一、封装

1.概念

2.private实现属性封装

3.封装的作用

4.其他

二、继承

1.概念

2.protected—继承访问权限

1）作用域

2）四大访问权限比较

3.继承语法

4.调用父类的有参构造

1）super关键字

2）this关键字

3）super vs this

5.对象的实例化流程

三、向上转型和向下转型

1.概念

类和对象的声明（3种情况）

2.向上转型（90%）

1）作用

2）向上转型一共发生在三个地方

3）方法重写/覆写override

4）方法重写 vs 方法重载

3.向下转型

1）什么时候需要向下转型（意义）

2）向下转型有风险

3）instanceof关键字—规避类型转换异常的错误

四、final关键字（终结器）

1.final修饰属性，表示该属性为常量，值不能修改

2.final修饰类，表示该类不能有子类（即无法被继承）

3.final修饰方法，表示该方法无法被重写

4.final+static修饰常量

五、多态

1.概念

2.分类

3.实现多态的条件

4.多态的好处

--------------------

## 一、封装 ##

### 1.概念 ###

封装是将代码隐藏起来，仅仅暴露一个访问接口来使用，在操作上使用get/set方法。即将方法和属性写到同一个类中，并将属性私有化，生成get/set方法，外部访问属性需要通过get和set方法，内部可以直接访问属性，这样的一个类我们认为它完成了封装。

### 2.private实现属性封装 ###

一个属性被private修饰，该属性只在类的内部可见，出了该类无法使用，不能直接通过对象访问（继承的类也不行）。

> 阿里编码规约：类中无特殊说明，所有的成员变量统一使用private（99%）封装，此时调用者无法直接调用。若要继续取得，设置操作private属性，直接调用类提供的getter/setter方法修改private修饰的内容。

public class Test {
    
        public static void main(String[] args) {
            card cd=new card();
            System.out.println(cd.getPassword());
            System.out.println(cd.getCardNumber());
    
        }
    
    }
    import java.util.Scanner;
    
    public class card {
        private int cardNumber=123456;
        private String password="123456789";
        private double sal;//余额
    
        public int getCardNumber() {
            return cardNumber;
        }
    
        public String getPassword() {
            return password;
        }
    
        public double getSal(String pass) {
            if(pass.equals(password))
            return sal;
            else{
                System.out.println("密码错误，请查证后再试");
            }
            return -1.0;
        }
    
        public void setPassword(String pass) {
            if(pass==password){
                System.out.println("密码正确，可以修改密码");
                Scanner sc=new Scanner(System.in);
                String newPassword=sc.next();
                password=newPassword;
            } else{
                System.out.println("密码不正确，无法修改");
            }
        }
    }

### 3.封装的作用 ###

保护性+易用性

1）提高程序安全性，保护数据，防止代码数据在无意中被破坏

2）隐藏代码实现细节，只要接口不变，内容的修改不会影响到外部的调用者（方法封装）

3）统一接口，保护类中的成员，不让类以外的程序直接访问或修改，只能通过提供的公共接口访问（数据封装）

4）系统可维护性大大增加，外部不能直接访问对象的属性，只能通过该属性对应的公有方法访问

1.  提高程序的安全性，保护数据：保护或防止代码（数据）在无意中被破坏。保护类中的成员，不让类以外的程序**直接访问或修改**，只能通过提供的**公共接口访问**（数据封装）
2.  隐藏代码的实现细节
3.  统一接口
4.  系统可维护性大大增加

### 4.其他 ###

1）private不能修饰外部类（内部类可以）：因为类定义就是为了产生对象

2）static不能修饰外部类：因为statuc是无对象可用，类的作用是产生对象，矛盾

## 二、继承 ##

### 1.概念 ###

继承是面向对象语言中一个代码复用的机制，简单说就是子类继承了父类中的非私有属性和可以继承的方法，然后子类可以继续扩展自己的属性及方法。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为，一个子类只能继承一个父类，但是可以多重继承，一个父类可以拥有多个子类。如某类B“继承”某类A，就把这个B称为“A的子类或派生类（subclass）”，而把类A称为“B的父类”也可以称为“A是B的超类或基类（superclass）”。

### 2.protected—继承访问权限 ###

一旦一个属性和方法被protected修饰，此时该属性和方法可以被子类使用【让子类可见】

#### 1）作用域 ####

**在不同包的具有继承关系的子类中可见**

eg:animal包下有animal类。zoo包下有dog类，dog是animal的子类，dog仍可访问animal，使用animal中的name,age,food等

#### 2）四大访问权限比较 ####

private<default<protected<public

default:包访问权限-同一包下同级目录可见【即同级目录的不同类可见】

protected:不同包有继承关系的类可见【同一包没有关系的类也可见（即包含default可以实现的内容但比default多了另外可以访问的空间），但并没有实际用处。】

### 3.继承语法 ###

子类 extends 父类

public class Test {
        public static void main(String[] args) {
            Dog dog=new Dog();
            dog.name="狗狗";
            dog.eat("狗粮");
            Cat cat=new Cat();
            cat.name="猫猫";
            cat.eat("猫粮");
        }
    }
    public class Animal {
        protected String name;
        public void eat(String food){
            System.out.println(name+"正在吃"+food);
        }
    }
    public class Cat extends Animal{
    }
    public class Dog extends Animal{
    }

1）Java中，使用extends继承一个父类，此时子类就具备了父类中所有public和protected域（属性和方法），但父类中的private属性和方法仍然不能直接访问。

2）Java中的继承是单继承局限，即一个子类只能使用extends继承一个父类，不允许多继承（不允许extends后面跟多个父类），但允许多层继承（例如鸭子是两栖动物的子类，两栖动物是动物的子类）

3）Java中所有的类都默认继承object类

4）eg:出错分析

![1063c1ead28b4f88b51c0c1ab703989a.png][]

name是子类person的对象（子类可见），可见，而animal.name是animal自己产生对象调用的，并且animal已经是在Animal包外创建了，所以不可见【继承是让子类可见，但这你用的是你自己，不可见】！

### 4.调用父类的有参构造 ###

public class Animal {
        protected String name;
        protected int age;
        public Animal(String name,int age){
            this.name=name;
            this.age=age;
        }
        public void eat(String food){
            System.out.println(this.name+"正在吃"+food);
        }
    }

public class Dog extends Animal{
        public Dog(String name,int age){
            //调用父类的有参构造，若父类中没有无参构造，必须在子类中通过super显示调用父类的有参构造
            super(name, age);
        }
        public void eat(String food){
            System.out.println("狗狗"+this.name+"正在吃"+food);
        }
    }

> public class Test \{
> 
> public static void main(String\[\] args) \{
> 
> Animal animal=new Animal("动物",0);
> 
> Dog dog=new Dog("二哈",2);
> 
> Cat cat=new Cat("野猫",3);
> 
> animal.eat("食物");
> 
> dog.eat("狗粮");
> 
> cat.eat("老鼠");
> 
> \}
> 
> \}

调用父类的有参构造，若父类中没有无参构造，必须在子类中通过super显示调用父类的有参构造。

#### 1）super关键字 ####

如果子类既想使用自己的方法，又想使用父类的成员变量和成员方法，需要通过super关键字。super的用法在子类的成员方法中访问父类的成员变量和成员方法，在子类的构造方法中访问父类的构造方法。

1）super调用父类的构造方法，必须放在构造方法的第一个

2）super必须只能出现在子类的方法或构造方法中

3）super和this不能同时调用构造方法

#### 2）this关键字 ####

构造方法（给类中属性赋值/对象初始化）的相互调用使用到this关键字，this()必须放在方法第一行。

1）this修饰属性，表示直接从本类中寻找属性，没找到去父类找

> class Person\{
> 
> String name;
> 
> int age;
> 
> public Person(String name;int age)\{
> 
> name=name;
> 
> this.age=age;
> 
> \}
> 
> \}

就近匹配原则，name这行代码相当于形参自己在给自己赋值，与类中定义的name无关，而this.age这样就是直接在本类中寻找到相应属性赋值。

2）this修饰方法，表示调用本类方法

调用本类的构造方法：this(参数)//必须写在首行，且不能成环

调用本类中普通方法：this.方法名称();

3）this表示当前对象引用

方法或属性通过哪个对象调用，this就是谁

#### 3）super vs this ####

1）this本身调用的是自身的对象

2）super代表的是父类对象的调用

3）this没有继承就可以使用，super必须在继承条件下使用

4）this()是本类的构造

2）super()是父类的构造

### 5.对象的实例化流程 ###

> Animal animal=new1 Dog()2;

1.先new:new一出来就产生了一个对象，此时在堆上开辟空间，对象中所有成员变量也就开辟空间了，也就都有默认值了

2.调用构造方法为成员变量赋值。若有继承，先调用父类的构造方法，而后才返回子类构造方法

（直接实例化对象：A a=new A(); 向上转型实例化对象(假如A是B父类)：A a=new B();）

## 三、向上转型和向下转型 ##

### 1.概念 ###

向上转型和向下转型是在继承中出现的情形，Java 语言允许某个类型的引用变量引用子类的实例，而且可以对这个引用变量进行类型转换。Java 中引用类型之间的类型转换（前提是两个类是父子关系）主要有两种，分别是向上转型（upcasting）和向下转型（downcasting）。

#### 类和对象的声明（3种情况） ####

> 1.自己声明自己：Person per=new Person();
> 
> 2.向上转型：Animal per=new Person();
> 
> 参数统一化，父类引用可以接收所有子类对象
> 
> 3.向下转型(要强转)
> 
> 要能够使用向下转型，必须先发生向上转型
> 
> Animal animal=new Dog();
> 
> //向下转型
> 
> Dog dog=(dog)animal;

### 2.向上转型（90%） ###

> 父类引用指向子类对象：父类名称 父类引用=new 子类实例();

public class Test {
        public static void main(String[] args) {
            Animal animal=new Animal("动物",0);
            Animal dog=new Dog("二哈",2);//⭐
            Animal cat=new Cat("野猫",3);//⭐
            animal.eat("食物");
            dog.eat("狗粮");
            cat.eat("老鼠");
        }
    }

#### 1）作用 ####

参数统一化：我们可以用一个父类引用接收所有子类实例。

eg:只要对象是Animal本身或者子类，都可以传入fun方法，fun中的animal可以是animal,dog,cat

public static void main(String[] args) {
        Animal animal=new Animal("动物",0);
        Animal dog=new Dog("二哈",2);
        Animal cat=new Cat("野猫",3);
        fun(animal,"食物");
        fun(dog,"狗粮");
        fun(cat,"老鼠");
    }
    public static void fun(Animal animal,String food){
        animal.eat(food);
    }

如果没有向上转型，animal有多少子类，fun方法就要重载多少次

public static void main(String[] args) {
        Animal animal=new Animal("动物",0);
        Dog dog=new Dog("二哈",2);
        Cat cat=new Cat("野猫",3);
        fun(animal,"食物");
        fun(dog,"狗粮");
        fun(cat,"老鼠");
    }
    public static void fun(Animal animal,String food){
        animal.eat(food);
    }
    public static void fun(Dog animal,String food){
        animal.eat(food);
    }
    public static void fun(Cat animal,String food){
        animal.eat(food);
    }

#### 2）向上转型一共发生在三个地方 ####

1）产生对象时 Animal dog=new Dog();  
2）方法参数传递⭐

public static void fun(Animal animal,String food){
        animal.eat(food);
    }

3）方法返回值

提问：Dog和Cat都定义了和父类Animal完全相同的eat，并且dog and cat都向上转型变为Animal类的引用，那么到底调用的eat是哪个类的eat()?

当发生向上转型时，若调用方法子类和父类中都有，我们要看的是到底通过哪个类new的对象，方法就调用该类的方法。Dog和Cat都定义了和父类Animal完全相同的eat，这就叫做方法的重写。

#### 3）方法重写/覆写override ####

在有继承关系的类之间，子类定义了和父类完全相同的方法(方法名称相同，参数相同，返回值相同或向上转型类的返回值，子类权限>=父类权限)

1）方法重写的三个要求

> a.只能重写成员方法/实例方法，不能重写静态方法

与重载非常大的区别：重载可以重载静态方法

> b.子类方法的权限修饰符>=父类方法

父类中public子类只能public，父类中是包访问权限，子类可以是包或public，注意，包访问权限一定要特别小心注意子类和父类是否是相同包，不同包时是不能覆写的。同时重写不能有private权限，private方法出了这个类就不可见，不可能覆写。

eg：父类animal中eat是包访问权限，子类dog中eat也是包访问权限，eat可否正确覆写？

不一定，当父类子类不同包时不能正确覆写。对于包访问权限来说，只对当前包同级目录下的类之间可见，对于不同包的animal和dog来说，dog类压根不知道animal还有eat方法，所以无法覆写。

> c.方法覆写的返回值必须相同，至少是向上转型的返回值

子类返回值必须是父类返回值的子类

2）方法重写的特点

a.方法名必须相同

b.参数列表必须相同

c.修饰符范围可以扩大不能缩小，不能private访问权限修饰

d.一定是在继承中子类重写父类的方法

e.重写只是方法体不同

#### 4）方法重写 vs 方法重载 ####

<table style="width:687px;"> 
 <tbody> 
  <tr> 
   <td style="text-align:center;width:93px;">比较</td> 
   <td style="text-align:center;width:258px;">方法重载</td> 
   <td style="text-align:center;width:333px;">方法重写</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:93px;">概念</td> 
   <td style="text-align:justify;width:258px;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;同一类下，方法名称相同、参数列表不同(类型or个数)、与返回值无关的方法称为重载方法</td> 
   <td style="text-align:justify;width:333px;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;在具有继承关系的类之间，子类定义了和父类完全相同的方法（名称、参数同，返回值同或向上转型的返回值，子类权限&gt;=父类）</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:93px;">作用范围</td> 
   <td style="text-align:center;width:258px;">同一类下</td> 
   <td style="text-align:center;width:333px;">父类与子类间</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:93px;">方法名</td> 
   <td style="text-align:center;width:258px;">相同</td> 
   <td style="text-align:center;width:333px;">相同</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:93px;">参数列表</td> 
   <td style="text-align:center;width:258px;">必须不同</td> 
   <td style="text-align:center;width:333px;">相同</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:93px;">返回值类型</td> 
   <td style="text-align:center;width:258px;">与返回值类型无关</td> 
   <td style="text-align:center;width:333px;">相同或向上转型的返回值</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:93px;">访问修饰符</td> 
   <td style="text-align:center;width:258px;">无关</td> 
   <td style="text-align:center;width:333px;">子类严于父类，不能private修饰</td> 
  </tr> 
  <tr> 
   <td style="text-align:center;width:93px;">都是实现多态的方式</td> 
   <td style="text-align:center;width:258px;">编译时多态</td> 
   <td style="text-align:center;width:333px;">运行时多态</td> 
  </tr> 
 </tbody> 
</table>

### 3.向下转型 ###

必须要强制类型转换（因为父类不一定是子类类型），要发生向下转型必须要发生向上转型（父类引用必须是通过子类new出来的-披着父类名称外衣的子类）

> 子类对象指向父类引用：子类 子类引用=（子类名称） 父类引用
> 
> Animal animal=new Dog();
> 
> //向下转型
> 
> Dog dog=(dog)animal;

能强转的原因：animal引用实际是Dog类new出来的

public class Cat extends Animal{
        public Cat(String name,int age){
            super(name,age);
        }
        public void eat(String food){
            System.out.println("猫猫"+this.name+"正在吃"+food);
        }
        public void yell(){
            System.out.println("喵呜");
        }
    }
    public class Animal {
        protected String name;
        protected int age;
        public Animal(String name,int age){
            this.name=name;
            this.age=age;
        }
         public void eat(String food){
            System.out.println("动物"+"正在吃"+food);
        }
    }
    
    
    public static void main(String[] args) {
        Animal animal=new Cat();
        //向下转型
        Cat cat=(Cat)animal;
        animal.eat("食物");
        animal.yell();//⭐错误，找不到yell()
        cat.yell();//✔
    }

> 类名称1 引用=new 类名称2();—>Animal animal=new Cat();

animal能调用什么方法是Animal决定的，animal引用的类型是指向Animal，animal调用的方法到底是哪个类的方法，要看new在哪：

animal.eat();//eat()在Animal定义了，可以调用。但是在Cat中覆写了，animal引用是通过Cat类new出来的，调用的是Cat类中的eat。animal.yell();//animal类中没有定义这个方法，就不能直接调用，这个方法是Cat类中独有的，因此我们需要通过向下转型将animal引用还原为Cat类型，通过cat.yell()调用。

#### 1）什么时候需要向下转型（意义） ####

我们需要使用子类独有的方法时，才将父类的引用还原【父类引用要使用子类扩展的方法时会用到】

#### 2）向下转型有风险 ####

1）若强转的两个类型没有关系，一定会出错

Dog dog=new Dog();

Cat cat=(Cat) dog;//一定报错

eg:⭐⭐

> Animal animal=new Animal();
> 
> Cat cat=(Cat)animal;
> 
> cat.yell();

分析：此时编译不会报错，但运行会报错【异常：ClassCastException—这个异常大多发生在向下转型时，父类引用并没有和子类建立联系，就会报这个错误【叫类型转换的异常】】。animal的引用指向animal的实例，与cat并无联系，而Animal animal=new Cat();为何对，因为这个animal指向Cat的实例，就是披着Cat外衣的animal，脱掉这个外衣就是一个Cat。

#### 3）instanceof关键字—规避类型转换异常的错误 ####

如何规避ClassCastException这个错误：instanceof关键字

用法：引用instanceof类，表示该引用是否指向这个类的实例

Animal animal=new Cat();
    if(animal instanceof Cat){
        //instanceof关键字返回一个boolean（布尔值）
        //表示一个引用是否是一个类的实例
        Cat cat=(Cat)animal;
        cat.yell();
    }

具体：[Java instanceof关键字详解][Java instanceof]

## 四、final关键字（终结器） ##

final表示最终的、不可变的

### 1.final修饰属性，表示该属性为常量，值不能修改 ###

基本数据类型：使用final修饰的基本数据类型值不能变，并且只能被赋值一次。

引用数据类型：使用final修饰的引用类型，引用的地址值不能改变，但是对象的属性值可以改变。

⭐final修饰的属性，不光值不能变，类型也不能变

![d1a13b9aaab6492989aceeeeb13adc09.png][]

分析：

> A：b1,b2是byte变量，运算时会先转为int，应强转回byte
> 
> D：final修饰的（b7）值不能变
> 
> C：int+byte->int,而b8是byte不是int，错误
> 
> ⭐⭐final修饰的属性，不光值不能变，类型也不能变//final byte b4=4,b5=6,b7=9;->不会被编译器转为int

### 2.final修饰类，表示该类不能有子类（即无法被继承） ###

JDK中的String类就是final修饰。final修饰的类不能有子类，说明该类在项目中有且只有一个【若String有子类，能继承的话，我们就可以自定义若干个String子类，就会造成一个现象：每个人用的String都可能不一样没法开发项目】

### 3.final修饰方法，表示该方法无法被重写 ###

final修饰的方法不能被覆写，子类只有使用权而没有修改权--类比加盟店食物的制作流程是final，加盟店只能使用【也算一种保护，保护制作流程，保护口碑】

（2，3点其实也是一种封装）

### 4.final+static修饰常量 ###

final修饰的实例变量一般添加 static修饰，static+final修饰的变量称为“常量”，常量名建议大写，每个单词间用下划线衔接。常量和静态成员变量可以做对比，区别在于常量的值不能变，相同点在于都是在类的加载时初始化（static修饰）。常量一般都是公共的，public修饰。

## 五、多态 ##

### 1.概念 ###

多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。

### 2.分类 ###

对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。

### 3.实现多态的条件 ###

3 个必要条件：继承、重写和向上转型。只有满足这 3 个条件，开发人员才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而执行不同的行为。

1）继承：多态中必须存在有继承关系的父类和子类

2）方法重写：子类对父类中某些方法重新定义，在调用这些方法时就会调用子类的方法

3）向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才既可以调用父类的方法，又能调用子类的方法

注意：当子类没覆写我们想让他覆写的方法时，编译是没有出错的（对于子类来说，方法覆写是一个可选项），但当我们想对子类做出强制性的要求，就要使用抽象类和抽象方法。

> 关于抽象类，见[面向对象编程之—抽象类和接口\_林纾y的博客-CSDN博客][y_-CSDN]

### 4.多态的好处 ###

1）提高了代码的可维护性：继承保证

2）提高了代码的扩展性：多态保证（方法覆写做到）

新加子类及功能不影响其他类和功能，方便扩展

3）降低使用者的使用门槛

类的使用者不需要了解类有哪些子类，只需要知道类的对象.方法名称()就可以执行一个子类的操作，举例如电脑USB接口，无需关心哪些类是USB的子类，只要是USB的子类都能用。

下一篇：[面向对象编程之—抽象类和接口\_林纾y的博客-CSDN博客][y_-CSDN]

[1063c1ead28b4f88b51c0c1ab703989a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/00744f9c193f4d518f1f7d43342cc09d.png
[Java instanceof]: http://c.biancheng.net/view/6346.html
[d1a13b9aaab6492989aceeeeb13adc09.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/0f16eed6256b474aa9b335f6c057dc0e.png
[y_-CSDN]: https://blog.csdn.net/m0_58006481/article/details/126453709?spm=1001.2014.3001.5502