Java基础：面向对象三特性（待更新）

短命女 2024-03-22 12:26 47阅读 0赞

## 1、封装 ##

字面意思，把东西装起来：隐藏、保护、提供方便使用的方式（例如快递打包、水管）。在这里指，将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，把尽可能多的东西藏起来，对外提供便捷的接口。

**用private关键字将属性隐藏，提供公共的访问接口getter/setter，如果有所限制，在setter中进行设置。**

好处：让编程变得简单，找对象、调方法就行。

### 1.1 private关键字 ###

private关键字，对属性进行私有化，被private修饰的成员只能在本类中访问。

**访问修饰符**：访问权限控制

◉ public：公共的，整个工程都可以访问

◌ protected：受保护的（包级私有+子类），除了本包之外，继承该类的所有子类也可以访问

◌ 默认的（无关键字）：包级私有，本类所在的包内所有的文件都可以访问

◉ private：私有的，本类内部才能访问

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <th>修饰符 \ 作用域</th> 
   <td>同一个类中</td> 
   <td>同一个包中</td> 
   <td>子类中</td> 
   <td>任何地方</td> 
  </tr> 
  <tr> 
   <td>private</td> 
   <td>可以</td> 
   <td>不可以</td> 
   <td>不可以</td> 
   <td>不可以</td> 
  </tr> 
  <tr> 
   <td>默认修饰符</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>不可以</td> 
   <td>不可以</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>不可以</td> 
  </tr> 
  <tr> 
   <td>public</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
   <td>可以</td> 
  </tr> 
 </tbody> 
</table>

被private修饰的成员，用之前我们调用成员变量方式会报错

//定义一个学生类
    public class Student{
        //private修饰的变量
        private String name;
        private int age;
        private String gender;
    }
    
    ==================================
    
    //测试类
    public class Test{
        public static void main(String[] args){
            Student s=new Student();
            s.name="张三";//报错
        }
    }

![ea80c94434df42e887b7d201f303428f.png][]

所以我们在使用private私有化后，要提供公共的访问接口：getter/setter。

### 1.2 getter/setter访问接口 ###

getter和setter分别对应属性的出口和入口：

> setter方法：给成员变量赋值
> 
> getter方法：对外提供成员变量的值

如果有特殊的条件限制，只能在setter中对赋值进行设定

getter是为了获取属性值，所以必然有return语句

//定义一个学生类
    public class Student {
    
        //private修饰的变量
        private String name;
        private int age;
        private String gender;
    
        //权限修饰符用public 表示是公共的，在所有的地方都能调用这个方法
        //setter方法：接收数据，给成员变量赋值，有参，无返回值
        public void setName(String name) {//给name赋值
            this.name = name;
        }
    
        //getter方法：对外提供，无参，有返回值
        public String getName() {//对外提供name属性
            return name;
        }
    
        //对年龄有限制，在setter方法中进行条件判断
        public void setAge(int a) {
            if(a>=18 && a<=22){
                age = a;
            }else{
                System.out.println("年龄超出范围");
        }
    
        public int getAge() {
            return age;
        }
    
        public void setGender(String gender) {
            //当成员变量名和形参参名一样时，用this指向成员变量
            //成员变量成员方法都需要用对象名调用，这里的this就代替了对象名
            this.gender = gender;
        }
    
        public String getGender() {
            return gender;
        }
    }
    
    ==================================
    
    //测试类
    public class Test {
        public static void main(String[] args){
            Student s1=new Student();
            s1.setName("张三");
            s1.setAge(16);
            System.out.println(s1.getName()+"的年龄是"+s1.getAge());
    
            Student s2=new Student();
            s2.setName("李四");
            s2.setAge(20);
            System.out.println(s2.getName()+"的年龄是"+s2.getAge());
        }
    }

输出结果：

年龄超出范围
    张三的年龄是0
    李四的年龄是20

由于张三的年龄超出年龄范围，系统取默认值为0.

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

getter和setter方法快速自动生成的 **快捷键**

> Alt+insert
> 
> ![33614656a4da46ae8f24478be98aeb44.png][]![2ffce5e44df643b58b9af7868a36c9d4.png][]

如果有有参构造，有参构造中的赋值也应该调用setter，以便调用setter的限制

### 1.3 包 ###

包，作为Java源代码的第一条语句，用package声明包，以分号结尾。

包名由小写字母组成，不能以圆点开头或结尾

> package声明第一行（忽略注释）
> 
> 其次是import
> 
> 然后是

**不要在src下直接写类，否则的话在别的包内是找不到这个类的**

###  ###

## 2、继承 ##

### 2.1 extends关键字 ###

子类共同的属性和方法，抽象出父类，子类用extends关键字基础父类的可见成员，java是单根继承，提高代码重用性，子类和父类满足is-a的关系

A extends B代表：A类继承了B类的**成员属性**和**成员方法**（可见的）。

在继承过程中，会默认创建父类对象，子类对象继承该父类对象的全部成员 ，实现代码重用。

java中只允许单根继承，一个类只能继承一个直接父类。（要想继承别的就定义一个“爷爷”类）

**Object类** 是 所有类的父类。

### 2.2 继承与构造方法 ###

1）当父类不存在无参构造时，子类会编译报错，因此父类必须有无参构造

![1bdf6b2a43a7480c819134942a7f5f1b.png][]

2）创建子类对象时，会先执行父类无参构造，再执行子类无参构造

public class Pet {//把Penguin和Dog公共的部分抽离出来做父类
        private String name;
        private int health;
        private int love;
    
        public Pet(String name, int health, int love) {
            this.name = name;
            this.health = health;
            this.love = love;
        }
    
        public Pet() {
            System.out.println("父类无参");
        }
    }
    ==========================================================
    public class Cat extends Pet{
        public Cat(){
            System.out.println("子类无参");
        }
    
    ==========================================================
    public class TestPet {
        public static void main(String[] args) {
            Cat c=new Cat();
        }
    }

运行结果：

父类无参
    子类无参

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

如果是创建有参对象 ，会先执行父类无参构造，再执行子类有参构造

public class Pet {//把Penguin和Dog公共的部分抽离出来做父类
        private String name;
        private int health;
        private int love;
    
        public Pet(String name, int health, int love) {
            this.name = name;
            this.health = health;
            this.love = love;
        }
    
        public Pet() {
            System.out.println("父类无参");
        }
    }
    ==========================================================
    public class Cat extends Pet{
        public Cat(){
            System.out.println("子类无参");
        }
        public Cat(int test){
            System.out.println("子类有参");
        }
    
    ==========================================================
    public class TestPet {
        public static void main(String[] args) {
            Cat c=new Cat();
        }
    }

运行结果：

父类无参
    子类有参

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

如果在子类构造方法中用super(...)来指定父类有参，则不再调用父类无参

public class Pet {//把Penguin和Dog公共的部分抽离出来做父类
        private String name;
        private int health;
        private int love;
    
        public Pet(String name, int health, int love) {
            System.out.println("父类有参");
            this.name = name;
            this.health = health;
            this.love = love;
        }
    
        public Pet() {
            System.out.println("父类无参");
        }
    }
    ==========================================================
    public class Cat extends Pet{
        public Cat(){
            System.out.println("子类无参");
        }
        public Cat(int test){
            super("aaa",1,1);
            System.out.println("子类有参");
        }
    
    ==========================================================
    public class TestPet {
        public static void main(String[] args) {
            Cat c=new Cat();
        }
    }

按住Ctrl鼠标悬浮在super关键字上方，可以看见super关键字 指向父类的 有参构造

![4e7f43eb401441b890f8d01f168828be.png][]

运行结果：

父类有参
    子类有参

### 2.3 Object类 ###

Object类 是 所有类的父类。

### 2.4 子类继承父类的... ###

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td></td> 
   <td>非私有</td> 
   <td>私有private</td> 
  </tr> 
  <tr> 
   <td>构造方法</td> 
   <td>不能继承</td> 
   <td>不能继承</td> 
  </tr> 
  <tr> 
   <td>成员变量</td> 
   <td>能继承</td> 
   <td><a href="https://www.bilibili.com/video/BV17F411T7Ao?t=587.6&amp;p=126" title="能继承，但不能直接使用" rel="nofollow">能继承，但不能直接使用</a></td> 
  </tr> 
  <tr> 
   <td>成员方法</td> 
   <td>能继承</td> 
   <td>不能继承</td> 
  </tr> 
 </tbody> 
</table>

*  继承public和protected修饰的属性和方法，不管子类和父类是否在同一个包里
 *  继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里![30dd48e24a2844b490bc40ddecd2c91b.png][]

子类与父类要符合 **is-a** 关系的设计

> is-a，顾名思义，是一个，代表继承关系。  
> 如果A is-a B，那么B就是A的父类。

## 3、多态 ##

同类型的对象，表现的不同形态。即 同一个引用类型，使用不同的实例对象而产生不同的操作结果，一个类型的方法在其子类中有多种不同的表现形式

父类的方法被多个子类重写的前提下，父类作为形参，子类对象作为实参在方法中调用了父类的被重写方法，会自动调用传入实参的重写后的子类方法

> 多态的前提：
> 
>  *  有继承/实现关系
>  *  有父类引用指向子类对象
>  *  有方法的重写

> 实现步骤:  
> 1、父子继承关系，且多个子类重写了父类的某一个方法
> 
> 2、父类的类型作为方法的形参类型，用形参调用父类的被重写的方法
> 
> 3、在实际调用时，以子类对象作为传入的实参能根据传入的子类类型，自动调用该类中重写后的方法

好处：可扩展性强，维护性高，代码量较少，提高了重用性。但耦合性高。

###  ###

[ea80c94434df42e887b7d201f303428f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/43df2285f3f942eabf786f9856d8e77d.png
[33614656a4da46ae8f24478be98aeb44.png]: https://img-blog.csdnimg.cn/33614656a4da46ae8f24478be98aeb44.png
[2ffce5e44df643b58b9af7868a36c9d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/b03a9927a3794a2eb48cf0b08a21fa25.png
[1bdf6b2a43a7480c819134942a7f5f1b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/8d0e0ac566044e5ab65a5bcdb60c8019.png
[4e7f43eb401441b890f8d01f168828be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c59aae4a39034e28996ed024e4c47a32.png
[30dd48e24a2844b490bc40ddecd2c91b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/028c541439864cef8a7e189476a3c8c4.png