封装、访问权限、继承—深入、super和this

本文链接：https://blog.youkuaiyun.com/qq_43647383/article/details/106696932

一、封装(encapsulation)特性

1.理解

防止该类的代码和数据被其他类随意访问，要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

2.原则

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

3.封装的步骤

使用private关键字来修饰成员变量
对需要访问的成员变量，提供对应的一对getXxx方法、setXxx方法

4.封装的操作——private关键字

1）private的含义

private是一个权限修饰符，代表最小权限
可以修饰成员变量和成员方法
被private修饰后的成员变量和成员方法，只在本类中才能访问

2）private的使用格式

private 数据类型变量名；

使用private修饰成员变量，代码如下：

public class Person {
    private String name;//姓名
    private boolean gender;//性别
    private int age;//年龄
}

提供getXxx方法/setXxx方法，可以访问成员变量，代码如下：

public class Person {
	public String getName(){
        return name;
    }
	public void setName(String name){
        this.name = name;
    }
    public boolean isGender() {
        return gender;
    }
    public void setGender(boolean gender) {
        this.gender = gender;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
}

二、访问权限

通过访问权限 public protected default private 来封装类、方法及属性，达到隐藏细节的目的，最终达到“该露的露，不该露的别瞎露” 目的。

在这里插入图片描述

private可以修饰成员变量，成员方法，构造方法，不能修饰类(此刻指的是外部类，内部类不加以考虑)

defalut即不写任何关键字，它可以修饰类，成员变量，成员方法，构造方法

protected可以修饰成员变量，成员方法，构造方法，但不能修饰类(此处指的是外部类，内部类不加以考虑)

public是权限最大的修饰符，他可以修饰类，成员变量，成员方法，构造方法

三、继承(inheritance)—深入

1.定义

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

2.好处

提高代码的复用性
类与类之间产生了关系，是多态的前提

3.继承后的特点——成员变量

1）成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

2）成员变量重名

如果子类父类中出现重名的成员变量，这时的访问是有影响的。

class Fu{
	//Fu中的成员变量
	int num=5;
}
class Zi extends Fu{
	//Zi中的成员变量
	int num=6;
	public void show(){
		//访问父类中的num
		System.out.println("Fu num="+num);
		//访问子类中的num
		System.out.println("Zi num="+num);
	}
}
class ExtendsDemo03{
	public static void main(String[]args){
		//创建子类对象
		Zi z = new Zi();
		//调用子类中的show方法
		z.show();
	}
}
演示结果：
Fu num=6
Zi num=6

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

super使用格式：

super.父类成员变量名

子类方法需要修改，代码如下：

class Zi extends Fu{
	//Zi中的成员变量
	int num = 6;
	public void show(){
		//访问父类中的num
		System.out.println("Funum="+super.num);
		//访问子类中的num
		System.out.println("Zinum="+this.num);
	}
}
演示结果：
Fu num=5
Zi num=6

4.继承后的特点——成员方法

1）成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。

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

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

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

代码如下：

class Fu{
	public void show(){
		System.out.println("Fu show");
	}
}
class Zi extends Fu{
	//子类重写了父类的show方法
	@Override
	public void show(){
		System.out.println("Zi show");
	}
}
public class Extends Demo05{
	public static void main(String[] args){
		Zi z = new Zi();//子类中有show方法，只执行重写后的show方法
		z.show();//Zi show
	}
}

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。

注意事项：

子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

5.继承后的特点——构造方法

1.构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。

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

代码如下：

class Fu{
	private int n;
	Fu(){
		System.out.println("Fu()");
	}
}
class Zi extends Fu{
	Zi(){
		//super（），调用父类构造方法super();
		super();
		System.out.println("Zi（）");
	}
}
public class ExtendsDemo07{
	public static void main(Stringargs[] args){
		Zi zi = new Zi();
	}
}
输出结果：
Fu（）
Zi（）

四、super和this

1.super和this的含义

super：代表父类的存储空间标识(可以理解为父亲的引用)
this：代表当前对象的引用(谁调用就代表谁)

2.super和this的用法

访问成员：

this.成员变量 ‐‐ 本类的
super.成员变量 ‐‐ 父类的
this.成员方法名() ‐‐ 本类的
super.成员方法名() ‐‐ 父类的

访问构造方法：

this(...) ‐‐ 本类的构造方法
super(...) ‐‐ 父类的构造方法

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