java——封装和继承_封装继承-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_69611919/article/details/143685946

1. 封装

在这里插入图片描述

1.1 封装的概念

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

比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互

1.2 访问限定符

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

no	范围	private	default	protected	public
1	同一包中的同一类	√	√	√	√
2	同一包中的不同类		√	√	√
3	不同包中的子类			√	√
4	不同包中的非子类				√

public：可以理解为一个人的外貌特征，谁都可以看得到
default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了
private：只有自己知道，其他人都不知道
【说明】
protected主要是用在继承中，继承部分详细介绍
default权限指：什么都不写时的默认权限
访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

package com.bit.demo1;
public class Computer {
    private String cpu;
    private String memory;
    public String screen;
    String brand;
    // cpu
    // 内存
// 屏幕
// 品牌
    public Computer(String brand, String cpu, String memory, String screen) {
        this.brand = brand;
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen;
    }
    public void Boot(){
        System.out.println("开机~~~");
    }
    public void PowerOff(){
        System.out.println("关机~~~");
    }
    public void SurfInternet(){
        System.out.println("上网~~~");
    }
}
 public class TestComputer {
 public static void main(String[] args) {
 Computer p = new Computer("HW", "i7", "8G", "13*14");
 System.out.println(p.brand);     // default属性：只能被本包中类访问
System.out.println(p.screen);    // public属性： 可以任何其他类访问
// System.out.println(p.cpu);       
}
 }

1.3 封装扩展之包

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一
个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。
类似于文件夹1中不能有同名的文件，但是在文件夹1中创建一个文件夹2，在文件夹2中可以创建一个和文件夹1同名的文件

2.继承

2.1 为什么需要继承

java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。
比如：狗和猫，它们都是一个动物。
在这里插入图片描述

我们定义一个猫类，一个狗类

class Animal{

}
class Dog{
    public String name;
    public int age;

    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }

    public void bark(){
        System.out.println(this.name+"正在汪汪汪");
    }
}
class Cat{
    public String name;
    public int age;
    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }

    public void bark(){
        System.out.println(this.name+"正在喵喵喵");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.age=10;
        dog.name="小白";
        dog.eat();;
        dog.bark();
        System.out.println("============");
        Cat cat=new Cat();
        cat.age=5;
        cat.name="皮卡丘";
        cat.eat();
        cat.bark();
    }
}

上述代码中我们发现有些共性，那能否将这些共性抽取呢？面向对象思想中提出了继承的概念，专门用来进行共性抽取，实现代码复用。

2.2 继承概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。
例如：狗和猫都是动物，那么我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用。
在这里插入图片描述
上述图示中，Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的
子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
从继承概念中可以看出继承最大的作用就是：实现代码复用，还有就是来实现多态(后序讲)。

2.3 继承的语法

在Java中如果要表示类之间的继承关系，需要借助extends（扩展）关键字，具体如下

修饰符 class 子类 extends 父类 { // ... }

对1.2中场景使用继承方式重新设计：

class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }


}
class Dog extends Animal{

    public void bark(){
        System.out.println(this.name+"正在汪汪汪");
    }
}
class Cat extends Animal{

    public void bark(){
        System.out.println(this.name+"正在喵喵喵");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        Dog dog=new Dog();
        dog.age=10;
        dog.name="小白";
        dog.eat();;
        dog.bark();
        System.out.println("============");
        Cat cat=new Cat();
        cat.age=5;
        cat.name="皮卡丘";
        cat.eat();
        cat.bark();
    }
}

注意：

子类会将父类中的成员变量或者成员方法继承到子类中了
子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

2.4 父类成员访问

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

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

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

class Base{
    public int a=10;
    public int b=20;
}
class Derived extends Base{
    public int c=30;
    public void method(){
        System.out.println(a);
        System.out.println(b);
        System.out.println(c;

    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Derived derived=new Derived();
        derived.method();
    }
}

结果为
a = 10; // 访问从父类中继承下来的a
b = 20; // 访问从父类中继承下来的b
c = 30; // 访问子类自己的c

子类和父类成员变量同名

class Base{
    public int a = 8;
    public int b = 20;
}
class Derived extends Base{
    public int a = 99;
    public void method(){
        System.out.println(a);// 与父类中成员a同名，且类型相同
        System.out.println(b);

    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Derived derived=new Derived();
        derived.method();
    }
}

运行结果为
a=99
b=20
由此可知当父类成员变量和子类成员变量同名时，优先使用子类的成员变量

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

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

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

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

成员方法名字不同

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()
    }
 }

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

成员方法名字相同

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.5 super关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

class Base{
    public int a = 8;
    public int b = 20;
}
class Derived extends Base{
    public int a = 99;
    public void method(){
        System.out.println(a);// 与父类中成员a同名，且类型相同
        System.out.println(super.a);
        System.out.println(b);

    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Derived derived=new Derived();
        derived.method();
    }
}

上述代码结果为：
99
8
20
在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可。
【注意事项】

只能在非静态方法中使用
在子类方法中，访问父类的成员变量和方法。

2.6子类构造方法

当我们在父类中写完一个构造方法，会发现报错
在这里插入图片描述
当子类继承父类之后，子类要先帮助父类初始化，子类在完成构造之前必须先完成对父类的构造

子类对象中成员是由两部分组成的，父类继承下来的以及子类新增加的部分。父子父子，先有夫才有子，所以构造子类对象的时候，先要调用父类的构造方法，将从父类继承下来的成员结构完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整
注意：

若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用父类构造方法
如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
super(…)只能在子类构造方法中出现一次，并且不能和this同时出现

2.7 this和super的区别

相同点：

都是java中的关键字
只能再类的非静态方法中使用，用来访问非静态成员方法和字段
在构造方法中调用时，必须是构造方法中的第一条语句并且不能同时存在

不同点：

this是对当前对象的引用，super是在子类中对父类成员的引用
在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
在构造方法中，this（）用于调用本类的构造方法，super（）用于调用父类构造方法，两种调用不能同时在构造方法中出现
构造方法中一定会存在super（）的调用，用户没有写编译器也会增加，但是this（）用户不写则没有

2.8 protected 关键字

为了实现封装特性，Java中引入了访问限定符，主要限定：类或者类中成员能否在类外或者其他包中被访问
protected的使用场景有三种：

同一包中的同一类
同一包中的不同类
不同包中的子类

2.9 继承方式

在现实生活中，事物之间的关系是非常复杂，灵活多样，比如：
在这里插入图片描述
当继承过多，后续修改代码也更加麻烦
在Java中只支持一下几种继承方式：

单继承

public class A{
    
}
public class B extends A{
    
}

多层继承

public class A{

}
public class B extends A{

}
public class C extends B{
    
}

不同继承同一类

public class A{

}
public class B extends A{

}
public class C extends A{

}

注意：Java中不支持多继承

2.10 final关键字

final关键可以用来修饰变量、成员方法以及类。

修饰变量或字段，表示常量(即不能修改)

 final int a = 10;
 a = 20;  // 编译出错

修饰类：表示此类不能被继承


 inal public class Animal {
 ...
 }
 public class Bird extends Animal {
 ...
 }
 // 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行继