09. Java基础&面向对象编程三大特性（封装、继承、多态）-CSDN博客

本文链接：https://blog.csdn.net/weixin_42378614/article/details/121882574

文章目录

1.封装

1.1封装概述

将方法和属性写到同一个类中，并将属性私有化，生成 get set方法，外部访问属性需要通过get和set方法,内部可以直接访问属性，这样的一个类我们认为它完成了封装。

封装可以隐藏实现细节，使得代码模块化；对于面向编程可以解释为：把客观事务封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

1.2 封装思想

封装概述是面向对象三大特征之一（封装，继承，多态）是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
封装原则将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法
封装好处通过方法来控制成员变量的操作，提高了代码的安全性把代码用方法进行封装，提高了代码的复用性

1.3 封装时权限控制符区别

	private	default	protected	public
同一类中	√	√	√	√
同一包中		√	√	√
子类			√	√
全局范围				√

1.4 示范代码

public class Demo{
    //对属性的封装
    private String name;
    ...
       
     public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
}

注：关于this的介绍可以观看 06. Java基础&面向对象

2.继承

2.1 继承概述

子类继承父类，子类实例可以调用父类除private修饰以外的所有属性和方法，一个子类只能继承一个父类，但是可以多重继承，一个父类可以拥有多个子类。

继承描述的是事物之间的所属关系，这种关系是：is-a的关系。例如：兔子属于食草动物，食草动物属于动物。由此可得，父类更通用，子类更具体。我们通过继承可以使多种事物之间形成一种关系体系。

定义：

继承：子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

2.2 继承的优缺点

优点：

提高了代码的复用性；
提高了代码的可维护性；
让类与类之间产生了关系，是多态的前提。

缺点：

类的耦合度增强了

2.3 继承的格式

通过 extends关键字，可以声明一个子类继承另一个父类，定义格式如下：

class 父类 { 
    ... 
}

class 子类 extends 父类 { 
    ... 
}

示范代码：

class Empoyee{
    String name;
    public void work(){
        System.out.println("工作");
    }
}

//定义教师类 继承 员工类
class Teacher extends Employee{
    public void teach(){
        System.out.println(name+"教书");
    }
}

//测试类
public class Demo{
    public static void main(String[] args){
        //创建教师类
        Teacher t=new Teacher();
        t.name="张三";
        t.teach();  //输出 “张三教书”
        
        t.work(); //输出 "工作"
    }
}

2.4 构造方法/构造器

除了那些private的外还有一样是子类继承不了的—构造器。对于构造器而言，它只能够被调用，而不能被继承。调用父类的构造方法我们使用super()即可。

构建过程是从父类”向外“扩散的，就是从父类开始向子类一级一级的完成构建。Java开发中：编译器会默认给子类调用父类的构造器。

默认调用父类的构造器有前提：父类有默认构造器。如果没有，必须用super() 来调用父类构造器。否则编译报错。

构造方法

构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

示范代码：

class Fu { 
    private int n;
    Fu(){ 
        System.out.println("Fu()");
    } 
}

class Zi extends Fu { 
    Zi(){ 
        // super（），调用父类构造方法 
        super(); 
        System.out.println("Zi（）");
    } 
}
public class ExtendsDemo07{ 
    public static void main (String args[]){ 
        Zi zi = new Zi();
    } 
}
输出结果： 
    Fu（）
    Zi（）

2.5 super和this

父类空间优先与子类对象产生

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

super和this的含义

super：代表父类存储空间标识（父类的引用）
this：代表当前对象的引用（谁调用代表谁）

super和this的用法

访问成员

this.成员变量 ‐‐ 本类的 
super.成员变量 ‐‐ 父类的 
    
this.成员方法名() ‐‐ 本类的 
super.成员方法名() ‐‐ 父类的

访问构造方法

this(...) ‐‐ 本类的构造方法 
super(...) ‐‐ 父类的构造方法

3.多态

3.1 多态概述

父类的引用指向子类的实例，多个子类继承同一个父类实现了这些类共通的方法，每一个子类实现的结果都不同。

多态的前提

要有继承或实现关系(继承是多态的基础,没有继承就没有多态).
要有方法重写(多态下调用子类重写的方法).
要有父类引用指向子类对象(子类到父类的类型转换).

重载（overload）和重写（override）是实现多态的两种主要方式

3.2多态的好处和弊端

好处

提高程序的扩展性，定义方法的时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。

弊端

不能使用子类的特有成员

3.3 多态中的转型

向上转型

父类引用指向子类对象就是向上转型

向下转型

格式：子类型对象名=（子类型）父类引用;

代码演示

动物类

public class Animal {
    public void eat() { 
        System.out.println("动物吃东西");
    } 
}

猫类

public class Cat extends Animal { 
    @Override 
    public void eat() { 
        System.out.println("猫吃鱼"); 
    }
    
    public void playGame() { 
        System.out.println("猫捉迷藏"); 
    } 
}

测试类

public class AnimalDemo {
    public static void main(String[] args) { 
        //多态 
        //向上转型 
        Animal a = new Cat(); 
        a.eat(); 
        // a.playGame();
            
       //向下转型 
        Cat c = (Cat)a; 
        c.eat(); 
       c.playGame();
    } 
}