2021大数据学习之旅 JavaSE·面向对象(继承、权限修饰符、包)

---

前言

系列文章比较适合非科班的同学, 由浅及深, 循序渐进, 从基础开始走上大数据之路

让我们一起努力, 达成目标, 实现理想

最后恳请留下你的小❤, 点赞给我一个小小的鼓励吧

---

一、类和对象部分回顾

1.1 类与对象

类

类在现实世界是不存在的，是一个模板，是一个概念，是人类大脑思考抽象的结果。类代表了一类事物，是一组相关属性和行为的集合。在现实世界中，对象A与对象B之间具有共同特征，进行抽象总结出一系列属性+行为的模板，这个模板被称为类

对象

是一类事物的具体体现，对象是实际存在的个体，现实世界当中实际存在。对象是类的一个实例（对象并不是处对象中的对象），必然具备该类事物的属性和行为。

编写一个符合JavaBean规范的类

public class JavaBeanTest {
    private int age;
    private String name;
    private boolean sex;
    private boolean isLoveJava;
    
    // 无参构造方法
    public JavaBeanTest() {
    }
    // 满参构造方法
    public JavaBeanTest(int age, String name, boolean sex, boolean isLoveJava) {
        this.age = age;
        this.name = name;
        this.sex = sex;
        this.isLoveJava = isLoveJava;
    }

    // get and set方法

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
	//以下需要注意
    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public boolean isLoveJava() {
        return isLoveJava;
    }

    public void setLoveJava(boolean loveJava) {
        isLoveJava = loveJava;
    }
}

需要注意的是，在手动编写布尔类型的私有属性时，get和set方法相对于变量名有所变化，参考上面例子中sex属性和isLoveJava属性

1.2 匿名对象

匿名对象,顾名思义就是没有名字的对象.也就是没有变量名的对象.匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量，即没有引用指向这块内存地址。

举例

public class Person{
	public void learning(){
		System.out.println("正在学Java");
	}
}

这时创建一个普通对象

Person p = new Person();

创建匿名对象

new Person();

1.3 匿名对象练习

创建一个集合，存储车类，向集合中添加任意数量的实例（自定义数量即可，使用匿名对象调用有参构造方法创建会比较方便），最后遍历本集合

import java.util.ArrayList;

public class OOTest05 {

    public static void main(String[] args) {
        ArrayList<Car> arr02 = new ArrayList<>();
        add(arr02, 3);
        bianLi(arr02);
    }
// 自动添加自定义个数的车辆实例，可以改写
    public static void add(ArrayList<Car> x, int n) {
        for (int i = 0; i < n; i++) {
            x.add(new Car(10 + 10 * i, "auto" + i));
            System.out.println("这是第" + x.size() + "次添加汽车");
        }
    }
// 遍历集合
    public static void bianLi(ArrayList<Car> x) {
        for (int i = 0; i < x.size(); i++) {
            System.out.println(x.get(i).getBrand());
        }
    }
}

//写在同个java文件中
//遵循JavaBean规范！
class Car {
    private int price;
    private String brand;

    public Car() {

    }

    public Car(int price, String brand) {
        this.price = price;
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand() {
        this.brand = brand;
    }

}

---

二、继承

2.1 概述

在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。例如教师、警察、医生都是人，他们都从人类模板（亚当，夏娃）中继承了的属性。

在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类、派生类、subclass，现有类被称作父类、超类、superclass，子类会自动拥有父类所有可继承的属性和方法。

继承的概念:当要定义一个类(教师)时，发现已有类(Person)和要定义的类相似(例如都有姓名，年龄等等)，并且要定义的类属于已有类的一种时，可以将要定义类定义为已有类的子类。同时也可以反过来思考，当多个类(教师、警察、医生)有共性内容，可以将共性内容向上抽取，抽取到一个新的类(Person)中,那么多个类和新的类形成的关系叫做继承。

2.2 继承的格式

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

class 父类 {
	...
}

class 子类 extends 父类 {
	...
}

举例

定义了一个Phone的父类，子类SmartPhone继承了父类，并且有自己独有方法

public class Phone {
    private String phoneNum;

    public Phone() { //无参构造
    }

    public Phone(String phoneNum) { //有参构造
        this.phoneNum = phoneNum;
    }

    public String getPhoneNum() {
        return phoneNum;
    }

    public void setPhoneNum(String phoneNum) {
        this.phoneNum = phoneNum;
    }

    public void phoneCall(){ //父类的方法一
        System.out.println("打电话");
    }

    public void showNum(){ //父类的方法二
        System.out.println(phoneNum);
    }
}


class SmartPhone extends Phone{
    private String location;

    public SmartPhone() {
    }

    public SmartPhone(String location) {
        this.location = location;
    }

    public String getLocation() {
        return location;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public void showLocation (){ //子类独有方法一
        System.out.println(location);
    }
    
}

测试类

public class TestPhone {
    public static void main(String[] args) {
        SmartPhone iphone =  new SmartPhone();
        iphone.setPhoneNum("12345678900");
        iphone.setLocation("上海");
        iphone.phoneCall();
        iphone.showLocation();
    }
}

在上述代码中，SmartPhone类通过extends关键字继承了Phone类，这样SmartPhone类便是Phone类的子类。从运行结果不难看出，子类虽然没有定义phoneNum属性和phoneCall方法，但是却能访问这两个成员，同时也不影响调用本类中独有的方法。这就说明，子类在继承父类的时候，会自动拥有父类的成员。

2.3 继承的优点

1. 基本作用：提高代码的复用性。
2. 最重要的作用：类与类之间产生了关系，是多态的前提。

2.4 继承后的特点——非私有成员变量

当类之间产生了关系后，其中各类中的成员变量，又产生了哪些影响呢？

如果子类父类中出现重名的成员变量，这时想访问对方的同名变量是有影响的，如下：

// 测试类
public class Test01 {
    public static void main(String[] args) {
        Zi a = new Zi();
        a.showNum(); //输出的结果是'父类：6'
        			 //		      '子类：6'
    }
}
// 父类
class Fu{
    int num = 5;
}
// 子类
class Zi extends Fu{
    int num = 6;
    public void showNum(){
		System.out.println("父类：" + num);
        System.out.println("子类：" + num);
    }
}

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用super 关键字，修饰父类成员变量，类似于之前学过的 this 。因此，子类中的输出语句应该改为：

class Zi extends Fu{
    int num = 6;
    public void showNum(){
		System.out.println("父类：" + super.num);
        System.out.println("子类：" + this.num); 
    }
}

小贴士：Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法供子类使用。

2.5 继承后的特点——非私有成员方法

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。如下：

public  class Test02{
    public static void main(String[] args) {
        Zi z = new Zi();
        //子类中没有show方法，但是可以找到父类方法去执行
        z.show();
        z.show2();
    }
}

class Fu{
    public void show(){
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu{
    public void show2(){
        System.out.println("Zi类中的show2方法执行");
    }
}

成员方法重名——重写(Override)

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

public  class Test03{
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show(); //结果为'Zi类中的show方法执行'
    }
}

class Fu{
    public void show(){
        System.out.println("Fu类中的show方法执行");
    }
}
class Zi extends Fu{
	// 和父类中的方法一模一样，方法的重写
    public void show(){
        System.out.println("Zi类中的show方法执行");
    }
}

子类可以根据需要，定义特属于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。拿之前Phone和SmartPhone作为例子，SmartPhone增加来电显示头像的功能，如下：

public class Test04 {
    public static void main(String[] args) {
        SmartPhone iphone = new SmartPhone();
        iphone.phoneCall();
        iphone.showNum();

    }
}


class Phone {

    public void phoneCall() {
        System.out.println("打电话");
    }

    public void showNum() {
        System.out.println("来电显示功能");
    }
}


class SmartPhone extends Phone {

    // 重写父类的来电显示功能
    @Override
    public void showNum() {
        super.showNum(); // 调用父类中已经写好的功能
        System.out.println("智能手机显示头像"); // 增加新功能
    }
}

小贴士：这里重写时，用到super.父类成员方法，表示调用父类的成员方法；用到的@Override标签，主要是告诉编译器帮你验证@Override下面的方法是否是对父类中成员方法的重写，如果不符合重写的要求就会报错

重点注意

1. 子类方法覆盖父类方法，必须要保访问证权限大于等于父类权限。
2. 子类方法覆盖父类方法，返回值类型、函数名和参数列表都要保持一致。
3. 私有方法不能被重写(父类私有成员子类是不能继承的)
4. (了解) 方法重写的时候，如果返回值类型是基本数据类型，必须保持一致；如果是引用数据类型，子类的返回值类型可以是父类返回值类型的子类

2.6 继承后的特点——构造方法

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先回忆两点，构造方法的定义格式和作用。然后通过实验（如下，创建多个子类）得出以下结论：

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

public class Test05 {
    public static void main(String[] args) {
        SmartPhone iphone = new SmartPhone();
    }
}

class Phone {
    public Phone(){
        System.out.println("父类无参构造方法");
    }
}

class SmartPhone extends Phone {
    public SmartPhone(){
        // super(); 这里放开与注释掉结果是相同的，系统默认会提供
        System.out.println("子类无参构造方法");
    }
}

2.7 super和this

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

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

在构造方法的执行过程中，一连串的调用了父类的构造方法，但是实际上对象只创建了一个，从内存图上可以看出还是同一块内存空间。

super和this的含义

• super ：代表父类的存储空间标识(可以理解为父亲的引用, 但是没有实际的地址值)。
• this ：代表当前对象的引用(谁调用就代表谁)。

super和this的用法

用法一 ：访问成员

格式：

this.成员变量  ----- 本类的
super.成员变量  ----- 父类的

this.成员方法名()  ----- 本类的
super.成员方法名()  ----- 父类的

举例：

class Animal {
    public void eat() {
        System.out.println("animal : eat");
    }
}
 
class Cat extends Animal {
    public void eat() {
        System.out.println("cat : eat");
    }
    public void eatTest() {
        this.eat();   // this  调用本类的方法
        super.eat();  // super 调用父类的方法
    }
}
 
public class Test06 {
    public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Cat c = new Cat();
        c.eatTest();
    }
}

用法二：访问构造方法

this(…)  ----- 本类的构造方法
super(…)  ----- 父类的构造方法

一定要注意：

• 子类的每个构造方法中均有默认的super()，调用父类的空参构造。
• 手动调用父类构造会覆盖默认的super()。
• super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

额外思考

super()到底是干什么的？

• super（实参）的作用是初始化当前对象的父类特征，并不是创建新的对象，实际上的对象只创建了一个

练习

下面的程序执行输出的结果是？

public static void main(String[] args){
    new C (); 
}

class A {
    public A() {
        System.out.println("1");
    }
}

class B extends A {
    public B() {
        System.out.println("2");
    }

    public B(int a) {
        System.out.println("3");
    }
}

class C extends B {
    public C() {
        this(20);
        System.out.println("4");
    }

    public C(int a) {
        this("zhangsan", 30);
        System.out.println("5");
    }

    public C(String a, int b) {
        super(40);
        System.out.println("6");
    }

上述的程序执行输出的结果是：

1 3 6 5 4

再次强调：当程序执行到3的时候，第一行其实默认的有一个super（），所以下一步直接跳到1

2.8 继承的特点

Java只支持单继承，不支持多继承

//一个类只能有一个父类，不可以有多个父类。
class C extends A{} 	//ok
class C extends A，B...	//error,A和B中有重名的变量/方法的话，系统编译无法做选择，有安全风险

Java支持多层继承(继承体系)

class A{}
class B extends A{}
class C extends B{}

所有的类都直接或者间接继承了Object类，Object类是所有类的父类。

万类之组，因此不管是new什么对象，object类的无参数构造方法一定会执行

---

三、抽象类

3.1 概述

由来

当编写一个类时，我们往往会为该类定义一些方法，这些方法是用来描述该类的功能具体实现方式，那么这些方法都有具体的方法体。分析事物时，发现了共性内容，就出现向上提取（称为抽象，动词）。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法。

如：

• 猫咪move()：猫咪正在走猫步
• 鸟move()：小鸟正在飞翔
• 鱼move()：小鱼正在游

​ 可以发现，猫咪、鸟、鱼有共同的特征 – 都属于动物，因此抽象成所属的共同类型：动物类。他们都具有move()方法，但是他们具体的行为内容却不一样。这时在定义动物类的move()方法时就发现了无法讲移动这个行为具体描述。So，这些不具体的方法，需要在类中标识出来，通过java中的关键字abstract(抽象)修饰。当定义了抽象函数的类也必须被abstract关键字修饰，被abstract关键字修饰的类是抽象类。

定义

• 抽象方法 ： 没有方法体的方法。
• 抽象类：包含抽象方法的类。

3.2 abstract使用格式

抽象方法

使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

举例：

public abstract void move();

抽象类

如果一个类包含抽象方法，那么该类必须是抽象类

定义格式：

public abstract class 类名 { }

举例：

public abstract class Animal{
	public abstract void move();
}

抽象类的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

在子类中将父类的抽象方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

abstract class Animal {
    public abstract void move();
}

// 哺乳类，依旧是抽象类
abstract class Mammals extends Animal {
    public abstract void move(); //没有实现继承的抽象方法，可以不写
}

class Bird extends Mammals {
    @Override
    public void move() {
        System.out.println("鸟儿在飞翔");
    }
}

public class Test {
    public static void main(String[] args) {
        Bird a = new Bird();
        a.move();
    }
}

3.3 注意事项

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

   理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义

2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

   理解：子类的构造方法中，有默认的super()，需要访问父类构造方法

3. 抽象类中，可以有成员变量。

   理解：子类的共性的成员变量 , 可以定义在抽象父类中

4. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

   理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计

5. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

   理解：假设不重写所有抽象方法，则子类中包含继承的抽象方法。那么子类依旧无法创建对象

---

四、综合案例 — 员工类体系

4.1 案例介绍

某IT公司有多名员工，按照员工负责的工作不同，进行了部门的划分（研发部员工、维护部员工）。研发部根据所需研发的内容不同，又分为JavaEE工程师、Android工程师；维护部根据所需维护的内容不同，又分为网络维护工程师、硬件维护工程师。

公司的每名员工都有他们自己的员工编号、姓名，并要做它们所负责的工作。

工作内容:

• JavaEE工程师： 员工号为xxx的 xxx员工，正在研发淘宝网站
• Android工程师：员工号为xxx的 xxx员工，正在研发淘宝手机客户端软件
• 网络维护工程师：员工号为xxx的 xxx员工，正在检查网络是否畅通
• 硬件维护工程师：员工号为xxx的 xxx员工，正在修复打印机

请根据描述，完成员工体系中所有类的定义，并指定类之间的继承关系。进行XX工程师类的对象创建，完成工作方法的调用。

4.2 代码实现

整体结构

参考

这里我就拿JavaEEEngineer作为一个例子，其余的各类留给大家自由发挥，有什么好的建议或者对代码有疑惑的，可以在评论区留言~

public abstract class Employee {
    private String name;
    private String id;

    public abstract void work();

    public Employee() {
    }

    public Employee(String name, String id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

abstract class Developer extends Employee{
    public Developer() {
    }

    public Developer(String name, String id) {
        super(name, id);
    }
}
//这个维护人员的抽象类留给大家练习啦，同理
abstract class Maintainer extends Employee{

}

class JavaEEEngineer extends Developer{
    public JavaEEEngineer() {
    }

    public JavaEEEngineer(String name, String id) {
        super(name, id);
    }

    @Override
    public void work() {
        System.out.println("员工："+getName()+"，编号："+getId()+"-->正在研发淘宝网站");
    }
}

测试类

public class TestEmp {
    public static void main(String[] args) {
        JavaEEEngineer a = new JavaEEEngineer("周杰伦", "8848");
        a.work();
    }
}

结果

员工：周杰伦，编号：8848–>正在研发淘宝网站

---

五、包的声明与访问

5.1 包的概念

java的包，其实就是我们电脑系统中的文件夹，包里存放的是程序生成的.class文件。

当.class文件很多的时候，通常我们会采用多个包进行存放管理他们，这种方式称为分包管理。

在项目中，我们将相同功能的类放到一个包中，方便管理。并且日常项目的分工也是以包作为边界。

类中声明的包必须与实际class文件所在的文件夹情况相一致，即类声明在a包下，则生成的.class文件必须在a文件夹下，否则，程序运行时会找不到类。

5.2 包的声明格式

通常使用公司网址反写，可以有多层包，包名采用全部小写字母，多层包之间用”.”连接

类中包的声明格式：

package 包名.包名.包名…;

举例

拿CSDN的网址做为例子，包名应该为net.csdn.editor

注意：声明包的语句，必须写在程序有效代码的第一行（注释不算）

package net.csdn.editor; //包的声明，必须在有效代码的第一行

import java.util.Scanner;
import java.util.Random;
public class Test {}

5.3 包的访问

在访问类时，为了能够找到该类，必须使用含有包名的类全名（包名.类名）

包的访问与访问权限密切相关，这里以一般情况来说，即类用public修饰的情况。

当我们要使用一个类时，这个类与当前程序在同一个包中（即同一个文件夹中），或者这个类是java.lang包中的类时通常可以省略掉包名，直接使用该类。

如：net.csdn.editor包中有两个类，Phone类与SmartPhone类。我们在SmartPhone类中，访问Phone类时，由于是同一个包下，访问时可以省略包名，即直接通过类名访问 Phone。

类名 变量名 = new类名();
Phone p = new Phone();

当我们要使用的类，与当前程序不在同一个包中（即不同文件夹中），要访问的类必须用public修饰才可访问。

5.4 import导包

我们每次使用类时，都需要写很长的包名。很麻烦，我们可以通过import导包的方式来简化。

可以通过导包的方式使用该类，可以避免使用全类名编写（即，包类.类名）。

导包的格式：

import 包名.类名;

当程序导入指定的包后，使用类时，就可以简化了。其实我们一直在使用了，并且IDEA具有自动导包的功能（真香）

//导入包前的方式
//创建对象
java.util.Random r1 = new java.util.Random();
java.util.Random r2 = new java.util.Random();
java.util.Scanner sc1 = new java.util.Scanner(System.in);
java.util.Scanner sc2 = new java.util.Scanner(System.in);

//导入包后的方式
import java.util.Random;
import java.util.Scanner;
//创建对象
Random r1 = new Random();
Random r2 = new Random();
Scanner sc1 = new Scanner(System.in);
Scanner sc2 = new Scanner(System.in);

注：import导包代码书写的位置：在声明包package后，定义所有类class前，使用导包import包名.包名.类名;

---

六、访问权限修饰符

其实我们已经接触过三种权限修饰符了：public、default（缺省）、private，后面接触到protected修饰符再做用法等介绍。这里先大致了解一下即可。

	本类	同包内	不同包中的子类	不同包中的非子类
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

---

总结

左上角主页里面有所有系列文章喔！

消除贫穷的最好办法就是和我一起学大数据，加油，奥利给！

看到这里点个赞吧!