Java面向对象之封装和继承-阿里云开发者社区

1. 封装

1.1 封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。

比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳

子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

1.2 访问限定符

Java 中对于字段和方法共有四种访问权限

private: 类内部能访问, 类外部不能访问

默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.

protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.（在继承部分详细介绍）

public : 类内部和类的调用者都能访问

微信图片_20230110154751.png

什么时候下用哪一种呢?

我们希望类要尽量做到 “封装”, 即隐藏内部实现细节, 只暴露出必要的信息给类的调用者.

因此我们在使用的时候应该尽可能的使用比较严格的访问权限. 例如如果一个方法能用 private, 就尽量不要用public.

另外, 还有一种简单粗暴的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用, 还是更希望同学们能写代码的时候认真思考, 该类提供的字段方法到底给 “谁” 使用(是类内部自己用, 还是类的调用者使用, 还是子类使用)

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

【说明】

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

一般情况下成员变量设置为private，成员方法设置为public。

1.3 封装扩展之包

包 (package) 是组织类的一种方式.

使用包的主要目的是保证类的唯一性.

例如, 你在代码中写了一个 Test 类. 然后你的同事也可能写一个 Test 类. 如果出现两个同名的类, 就会冲突, 导致代码不能编译通过，若在包中建立类，就避免了类名冲突的情况

1.3.1 导入包中的类

Java 中已经提供了很多现成的类供我们使用. 例如

public class Test {
    public static void main(String[] args) { 
    java.util.Date date = new java.util.Date(); // 得到一个毫秒级别的时间戳 
    System.out.println(date.getTime());
   }
}

可以使用 java.util.Date 这种方式引入 java.util 这个包中的 Date 类. 但是这种写法比较麻烦一些, 可以使用 import 语句导入包.

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
        }
}

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*,*又叫做通配符，用了它就可以使用包中的所有类，但又不像c/c++一样全部导入，而是使用哪个类就导哪个类

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Date date = new Date();
        // 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
   }
}

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
   }
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
  java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

在这种情况下需要使用完整的类名，才能避免冲突

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        System.out.println(date.getTime());
   }
}

1.3.2将类放到包中

基本规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中.
包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中.
包名必须小写

操作步骤

1.在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

微信图片_20230110154756.png

2.在弹出的对话框中输入包名, 例如 com.bilibili.demo1

微信图片_20230110154759.png

3.在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可

微信图片_20230110154802.png

4.此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

微信图片_20230110154808.png

5.同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

微信图片_20230110154811.png

1.3.3 import和package的区别

package：“包”，指：类所在的包

import:“引入”，指：引入类中需要的类。

也就是说在类所在的包需要使用package语句，如果一个类没有package语句它也会被默认放入一个包中，而import是因为当前类需要其他包中的类，所以才需要导入。

1.3.4包的访问权限控制

我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用.

如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用.

下面的代码给了一个示例. Demo1 和 Demo2 是同一个包中, Test 是其他包中.

Demo1.java

package com.bilibili.demo1;
public class Demo1 {
    int value = 0; //在不加任何关键字修饰时，默认为包访问权限
}

Demo2.java

package com.bilibili.demo1; 
public class Demo2 { 
 public static void Main(String[] args) { 
 Demo1 demo = new Demo1(); 
 System.out.println(demo.value); 
 } 
} 
// 执行结果, 能够访问到 value 变量
10

Test.java

import com.bilibili.demo1.Demo1; 
public class Test { 
 public static void main(String[] args) { 
 Demo1 demo = new Demo1(); 
 System.out.println(demo.value); 
 } 
} 
// 编译出错
Error:(6, 32) java: value在com.bilibili.demo1.Demo1中不是公共的; 无法从外部程序包中对其进行访问

1.3.5 常见的系统包

1.java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2.java.lang.reflect:java 反射编程包;

3.java.net:进行网络编程开发包。

4.java.sql:进行数据库开发的支持包。

5.java.util:是java提供的工具程序包。(集合类等) 非常重要

6.java.io:I/O编程开发包。

2. 继承

2.1 背景

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).

有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联.

例如, 设计一个类表示动物

注意, 我们可以给每个类创建一个单独的 java 文件. 类名必须和 .java 文件名匹配(大小写敏感)

// Animal.java 
public class Animal { 
 public String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Cat.java 
class Cat { 
 public String name; 
 public Cat(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Bird.java 
class Bird { 
 public String name; 
 public Bird(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
 public void fly() { 
 System.out.println(this.name + "正在飞 ︿(￣︶￣)︿"); 
 } 
}

这个代码我们发现其中存在了大量的冗余代码.

仔细分析, 我们发现 Animal 和 Cat 以及 Bird 这几个类中存在一定的关联关系:

这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.
从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义).

微信图片_20230110154816.png

此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果，此时, Animal 这样被继承的类, 我们称为父类 , 基类或超类, 对于像 Cat 和 Bird 这样的类, 我们称为子类, 派生类，和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果。

面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

2.2 语法规则

基本语法

class 子类 extends 父类 { 
}

使用 extends 指定父类.
Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
子类构造的同时要先帮父类进行构造
子类会继承父类的所有 public 的字段和方法.(构造方法也会继承，不过比较麻烦)
对于父类的 private 的字段和方法, 子类中是无法访问的.（也可以继承但无法访问）
子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

对于上面的代码, 可以使用继承进行改进. 此时我们让 Cat 和 Bird 继承自 Animal 类, 那么 Cat 在定义的时候就不必再写 name 字段和 eat 方法.

class Animal { 
 public String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
class Cat extends Animal { 
 public Cat(String name) { 
 // 使用 super 调用父类的构造方法,若父类中无构造方法，则可以不构造
 super(name); //可以理解为儿子和父亲都有名字这个属性
 } 
} 
class Bird extends Animal { 
 public Bird(String name) {
  super(name); 
 } 
 public void fly() { 
 System.out.println(this.name + "正在飞 ︿(￣︶￣)︿"); 
 } 
} 
public class Test { 
 public static void main(String[] args) { 
 Cat cat = new Cat("小黑"); //可以理解为儿子和父亲都有名字这个属性，只是把“小黑”这个名字赋给了儿子。
 cat.eat("猫粮"); 
 Bird bird = new Bird("圆圆"); 
 bird.fly(); 
 } 
}

extends 英文原意指 “扩展”. 而我们所写的类的继承, 也可以理解成基于父类进行代码上的 “扩展”.

例如我们写的 Bird 类, 就是在 Animal 的基础上扩展出了 fly 方法

如果我们把 name 改成 private, 那么此时子类就不能访问了

class Bird extends Animal { 
 public Bird(String name) { 
 super(name); 
 } 
 public void fly() { 
 System.out.println(this.name + "正在飞 ︿(￣︶￣)︿"); 
 } 
} 
// 编译出错
Error:(19, 32) java: name 在 Animal 中是 private 访问控制

2.3 父类成员访问

在继承体系中，子类将父类中的方法和字段继承下来了，那在子类中能否直接访问父类中继承下来的成员呢？

2.3.1子类中访问父类的成员变量

1.子类和父类不存在同名成员变量

public class Base { 
  int a; 
  int b; 
}
public class Derived extends Base{ 
  int c;
  public void method(){ 
    a = 10; // 访问从父类中继承下来的a 
    b = 20; // 访问从父类中继承下来的b 
    c = 30; // 访问子类自己的c 
  } 
}

2.子类和父类成员变量同名

public class Base { 
  int a; 
  int b; 
  int c; 
}
/
public class Derived extends Base{ 
  int a; // 与父类中成员a同名，且类型相同
  char b; // 与父类中成员b同名，但类型不同
  public void method(){ 
    a = 100; // 访问父类继承的a，还是子类自己新增的a？ 
    b = 101; // 访问父类继承的b，还是子类自己新增的b?
    c = 102; // 子类没有c，访问的肯定是从父类继承下来的c 
    // d = 103; // 编译失败，因为父类和子类都没有定义成员变量b 
  }
}

在子类方法中或者通过子类对象访问成员时：

如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

2.3.2 子类中访问父类的成员方法

1.成员方法名字不同

public class Base {
  public void methodA(){ 
   System.out.println("Base中的methodA()"); 
  } 
}
public class Derived extends Base{
  public void methodB(){ 
   System.out.println("Derived中的methodB()方法"); 
}
  public void methodC(){
   methodB(); // 访问子类自己的methodB()
   methodA(); // 访问父类继承的methodA() 
   // methodD(); // 编译失败，在整个继承体系中没有发现方法methodD() 
  } 
}

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

2.成员方法名字相同

public class Base {
  public void methodA(){ 
   System.out.println("Base中的methodA()"); 
  }
  public void methodB(){ 
   System.out.println("Base中的methodB()"); 
  } 
}
public class Derived extends Base{
  public void methodA(int a) { 
   System.out.println("Derived中的method(int)方法"); 
  }
  public void methodB(){ 
   System.out.println("Derived中的methodB()方法"); 
  }
  public void methodC(){
   methodA(); // 没有传参，访问父类中的methodA()
   methodA(20); // 传递int参数，访问子类中的methodA(int)
   methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，基类的无法访问到 
  } 
}

【说明】

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。

通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

2.4 super关键字

如果需要在子类内部调用父类方法或成员需要怎么做?

可以使用super 关键字.

super 表示对父类实例的引用.

super（）来调用父类的构造方法
super.fun（）来调用父类的普通方法
super.data来调用父类的成员属性

小总结.super和this的区别

(1.)代表的事物不同
        super代表的是父类空间的引用
        this代表的是所属函数的调用者对象
    (2.)使用前提不同
        super必须要有继承关系才能使用
        this不需要继承关系也能使用
    (3.)调用的事物不同
         super：调用父类的构造方法（必须在第一行），普通方法或成员变量
         this：调用所属类的构造方法（必须在第一行），普通方法或成员变量

2.5 再谈初始化

代码块在继承关系上的执行顺序

class Person {
  public String name;
  public int age;
  public Person(String name, int age) { 
   this.name = name; 
   this.age = age; 
   System.out.println("Person：构造方法执行"); 
  }
  { 
   System.out.println("Person：实例代码块执行"); 
  }
  static { 
   System.out.println("Person：静态代码块执行"); 
  } 
}
class Student extends Person{
  public Student(String name,int age) { 
   super(name,age); 
   System.out.println("Student：构造方法执行"); 
  }
  { 
   System.out.println("Student：实例代码块执行"); 
  }
  static { 
   System.out.println("Student：静态代码块执行"); 
  } 
}
public class TestDemo {
  public static void main(String[] args) { 
   Student student1 = new Student("张三",19); 
   System.out.println("==========================="); 
   Student student2 = new Student("gaobo",20);
  }
  public static void main1(String[] args) { 
   Person person1 = new Person("bit",10); 
   System.out.println("============================"); 
   Person person2 = new Person("gaobo",20); 
  } 
}

执行结果：

Person：静态代码块执行 
Student：静态代码块执行 
Person：实例代码块执行 
Person：构造方法执行 
Student：实例代码块执行 
Student：构造方法执行 
=========================== 
Person：实例代码块执行 
Person：构造方法执行 
Student：实例代码块执行 
Student：构造方法执行

通过分析执行结果，得出以下结论：

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

2.6 protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 “封装” 的初衷.两全其美的办法就是 protected 关键字.

对于类的调用者来说, protected 修饰的字段和方法是不能访问的
对于类的子类（可以同一个包也可以不是同一个）和同一个包的其他类来说, protected修饰的字段和方法是可以访问的

// Animal.java 
public class Animal { 
 protected String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Bird.java 
public class Bird extends Animal { 
 public Bird(String name) { 
 super(name); 
 } 
 public void fly() { 
 // 对于父类的 protected 字段, 子类可以正确访问
 System.out.println(this.name + "正在飞 ︿(￣︶￣)︿"); 
 } 
} 
// Test.java 和 Animal.java 不在同一个 包 之中了. 
public class Test { 
 public static void main(String[] args) { 
 Animal animal = new Animal("小动物"); 
 System.out.println(animal.name); // 此时编译出错, 无法访问 name 
 } 
}

2.7 更复杂的继承关系

刚才我们的例子中, 只涉及到 Animal, Cat 和 Bird 三种类. 但是如果情况更复杂一些呢?针对 Cat 这种情况, 我们可能还需要表示更多种类的猫

微信图片_20230110154824.png

这种情况将会出现更复杂的继承关系，一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.如果想从语法上进行限制继承, 就可以使用 final 关键字.

2.8 final 关键字

曾经我们学习过 final 关键字, 修饰一个变量或者字段的时候, 表示常量 (不能修改).

final int a = 10; 
a = 20; // 编译出错
final 关键字也能修饰类, 此时表示被修饰的类就不能被继承.
final public class Animal { 
 ... 
} 
public class Bird extends Animal { 
 ... 
} 
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继承

final 关键字的功能是限制类被继承"限制" 这件事情意味着 “不灵活”. 在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.

使用 final 修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的

我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承

Java面向对象之封装和继承