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面向对象之封装和继承

1. 封装

1.1 封装的概念

1.2 访问限定符

1.3 封装扩展之包

1.3.1 导入包中的类

1.3.2将类放到包中

1.3.3 import和package的区别

1.3.4包的访问权限控制

1.3.5 常见的系统包

2. 继承

2.1 背景

2.2 语法规则

2.3 父类成员访问

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

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

2.4 super关键字

2.5 再谈初始化

2.6 protected 关键字

2.7 更复杂的继承关系

2.8 final 关键字

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java面向对象之封装和继承

1. 封装

1.1 封装的概念

1.2 访问限定符

1.3 封装扩展之包

1.3.1 导入包中的类

1.3.2将类放到包中

1.3.3 import和package的区别

1.3.4包的访问权限控制

1.3.5 常见的系统包

2. 继承

2.1 背景

2.2 语法规则

2.3 父类成员访问

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

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

2.4 super关键字

2.5 再谈初始化

2.6 protected 关键字

2.7 更复杂的继承关系

2.8 final 关键字

热门文章

最新文章

相关课程

相关电子书

相关实验场景