封装与继承（二）

封装与继承（二）

• 封装
• 权限修饰符
• 继承
• final 关键字

第一章 封装

第01节 基础理论

面向对象三大特性

1. 封装性
2. 继承性
3. 多态性

什么是封装呢？

类的封装

封装就是对 一些属性和行为的包装。将属性和行为包装成为类。通过创建对象的方式，去使用属性和行为。

生活实例：
	有一个名字叫旺财的事物，他有3岁，可以看家，可以吃肉，还可以卖萌，还可以溜。
	那么我们将这种 属性和行为封装成为狗。
 	使用狗的对象，就可以完成上面的操作（旺财、3岁、看家、卖萌....）

方法封装

我们将一些常用的写法，常用的逻辑，封装成为一个方法，直接调用方法就可以了。
例如：如果我们对于数组的循环遍历，操作比较多。这种情况下，我们就可以将数组的循环遍历，封装成为方法。
系统提供了一个方法 Arrays.toString(数组名称);  这里 toString()方法当中的细节，不让你看到，直接丢参数，得到结果就可以。

属性封装

有时候，我们需要将属性（成员变量）隐藏起来，不让外界访问，这种情况下可以使用 private 关键字。
这里如果采用 private 去修饰成员变量，外界是不能直接访问的。这也是属性封装的一种体现。

第02节 private封装

案例代码

学生类

//学生类
public class Student {

    String name;
    private int age;

    //构造方法
    public Student(String name, int age) {
        this.name = name;
        if(age>=0 && age < 400) {
            this.age = age;
        }
    }

    public void show(){
        System.out.println("name = " + name);
        System.out.println("age = " + age);
    }
}

学生类

//测试类
public class Test {

    public static void main(String[] args) {

        //创建对象
        //Student stu = new Student();
        //stu.name = "赵兴哲";
        //stu.age = -20;
        Student stu = new Student("赵兴哲",-20);
        stu.show();
    }
}

效果图

第03节 JavaBean

理论说明

JavaBean 是类的一种标准写法：包含有 
	1. 成员变量 private修饰
	2. 成员方法 getXxx 和 setXxx 
	3. 构造方法 无参数构造方法 和 全参数构造方法
	
快捷键：
	在代码区域，右键选择 Gener... 生成构造方法 Con... 生成 getter And setter

案例代码

手机类

//手机类
public class Phone {

    //成员变量
    private String brand;
    private int price;

    public Phone() {
    }

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

    public String getBrand() {
        return brand;
    }

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

    public int getPrice() {
        return price;
    }

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

测试类

//测试类
public class Test {

    public static void main(String[] args) {

        //使用方式一：无参数构造+setXxx 赋值 getXxx取值
        Phone one = new Phone();
        one.setBrand("华为P40");
        one.setPrice(8000);
        String brand1 = one.getBrand();
        int price1 = one.getPrice();
        System.out.println("brand1 = " + brand1);
        System.out.println("price1 = " + price1);

        //使用方式二：全参数构造 赋值  getXxx取值
        Phone two = new Phone("小米8S",4000);
        String brand2 = two.getBrand();
        int price2 = two.getPrice();
        System.out.println("brand2 = " + brand2);
        System.out.println("price2 = " + price2);
    }
}

第二章 权限修饰符

第01节 基础理论

权限修饰符是什么意思呢？

权限修饰符就是 指明： 类、方法、变量。他们的作用范围。 在什么地方可以使用到他们。

例如: 变量
	1. 在不同的包当中，想要去使用变量，应该使用什么权限修饰符？
	2. 在同一个包，不同类当中，想要去使用变量，应该使用什么权限修饰符?
	3. 在不同的包，但是属于父子类关系，可以使用什么权限修饰符?
	4. 只能在同一个类当中，应该使用什么权限修饰符?
	
小结:
	权限修饰符干嘛用的?
	解决在不同位置，访问权限的问题。

常用的权限修饰符有哪些呢？（从大到小）

1. public  		公共的 【使用较多】
2. protected 	受保护的
3. 不写		  默认的
4. private      私有的 【使用较多】

第02节 不同修饰符

	public 公共的	protected 受保护的	不写 默认的	private 私有的
不同包，不同类（陌生人）	YES	NO	NO	NO
不同包，子类（我儿子）	YES	YES	NO	NO
同一个包，非子类（我邻居）	YES	YES	YES	NO
同一个包，同一个类（我自己）	YES	YES	YES	YES

小结： 重点是 public 和 private

1、什么时候采用 public ？

​ 类使用 public

​ 构造方法 使用 public

​ 成员方法 使用 public

2、什么时候采用 private ？

​ 成员变量 使用 private

​ 单例模式和工具类的 构造方法 使用 private

第三章 继承

第01节 继承的格式

格式

class 父类名称{
    
}

class 子类名称 extends 父类名称{
    
}

案例

小结

继承有什么作用呢?
向上抽取共性，提高代码的复用性。（大白话：偷懒的一种思想）

第02节 成员变量特点

案例代码

父类

//父类
public class FuLei {
    String name = "王健林";
    int ageFu = 60;
}

子类

//子类
public class ZiLei extends FuLei{
    String name = "王思聪";
    int ageZi = 30;

    public void show(){
        String name = "熊猫TV";
        System.out.println(name); //熊猫TV
        System.out.println(this.name);  //王思聪
        System.out.println(super.name); //王健林
    }
}

测试类

//目标：继承当中，成员变量的特点
public class Test {

    public static void main(String[] args) {

        //创建子类的对象，调用成员变量
        ZiLei zi = new ZiLei();

        System.out.println(zi.ageFu); // 60
        System.out.println(zi.ageZi); // 30
        System.out.println(zi.name); //王思聪
        //规则: 成员变量，看等号左边，左边是谁，优先使用谁，没有则向上找
        System.out.println("---------");
        zi.show();
    }
}


//如果在子类方法当中，想要去访问变量。遵循的是"就近原则"
//就近原则：谁离我近，我就优先使用谁。
//如果想要打破就近原则，则需要使用关键字 this 和 super
//如果采用的是 this.变量名称 则表示 本类成员变量
//如果采用的是 super.变量名称 则表示 父类成员变量

效果图

第03节 成员方法特点

案例代码

父类

//父类
public class FuLei {

    public void methodFu(){
        System.out.println("父类不同方法");
    }

    public void show(){
        System.out.println("父类相同方法");
    }
}

子类

//子类
public class ZiLei extends FuLei{

    public void methodZi(){
        System.out.println("子类不同方法");
    }

    public void show(){
        System.out.println("子类相同方法");
    }

    public void function(){
        this.show(); //子类相同方法
        super.show(); //父类相同方法
    }
}

测试类

public class Test {

    public static void main(String[] args) {
        //创建子类的对象，调用方法
        ZiLei zi = new ZiLei();
        zi.methodFu(); //父类不同方法
        zi.methodZi(); //子类不同方法
        zi.show();  //子类相同方法

        //规则：成员方法看等号右边，等号右边是谁，则优先使用谁，没有就向上找
        System.out.println("-----");
        zi.function();

    }
}

第04节 方法重写

基础理论

1. 什么是方法重写呢?
	在父子关系当中，出现了子类方法和父类方法，声明相同的情况。（方法名称相同，参数列表相同，返回值相同）

2. 两个易混淆的概念：
	A. 方法重载: 同一个类，同名方法，参数不同。（参数的类型不同，参数的顺序不同，参数的个数不同）
	B. 方法重写: 父子关系，相同方法。（出现在两个类当中的方法）

3. 方法重写有什么作用呢?
	当父类方法无法完全满足，现有子类需求的情况下，我们就可以在子类当中，对父类方法进行重写，满足现有的儿子需求。

效果图

案例代码

手机类 父类

//手机类
public class Phone {

    public void call(){
        System.out.println("显示号码");
    }
}

新手机类 子类

//新款手机
public class NewPhoe extends Phone{

    //注解 Override 表示检查是否是正确的方法重写
    @Override
    public void call(){
        super.call();
        System.out.println("显示头像");
        System.out.println("显示名称");
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {

        //创建子类的对象
        NewPhoe np = new NewPhoe();
        //调用方法
        np.call();
    }
}

//显示号码
//显示头像
//显示名称

//方法重写的应用场景:
//当父类方法无法满足现有子类需求的时候，在子类当中，选择方法重写
//经典的场景就是 升级工作

注意事项

一大一小：

一大：子类的权限修饰符 >= 父类权限修饰符  【父类私有方法，不能被重写】
一小：子类的返回值类型 <= 父类的返回值类型  class Integer extends Number extends Object{ ... }

第05节 构造方法特点

基础理论

1. 继承当中，构造方法的访问特点是什么?
	在创建子类对象的时候，优先执行父类构造，再去执行子类构造。

2. 原因是什么呢?
	因为在子类当中，可能会使用到父类的成员变量，必须先帮父类初始化成员变量。

3. 注意事项:
	在任何一个构造方法的第一行都是 super(); 不写的时候，系统会默认赠送一个给你。
	如果写了 super(参数) 或者是 this(参数) 系统将不再赠送 super()；
	目的是为了让你访问父类的构造方法。

案例代码

父类

//父类
public class FuLei {

    private String name;
    private int age;

    public FuLei() {
    }

    public FuLei(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

子类

//子类
public class ZiLei extends FuLei {

    private String gender;

    public ZiLei() {

    }

    public ZiLei(String name, int age, String gender) {
        super(name, age);
        this.gender = gender;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

测试类

//测试类
public class Test {

    public static void main(String[] args) {
        //创建子类对象
        ZiLei zi = new ZiLei("定浩",18,"女");
        //获取值
        String name = zi.getName();
        int age = zi.getAge();
        String gender = zi.getGender();

        System.out.println("name = " + name);
        System.out.println("age = " + age);
        System.out.println("gender = " + gender);
    }
}

第06节 继承的特点

继承特点

单一继承，多层继承。

单一继承： 一个类只能有一个直接父类。（只能有一个亲爹）
多层继承： 一个类除了有一个亲爹外，还可以有亲爷爷。（有爹有爷）

画图说明

第07节 两个关键字

基础理论

1. this
	A. 含义:
		当前对象的引用
	B. 用法：
		a. 成员变量 this.变量名称
		b. 成员方法 this.方法名称(参数);
		c. 构造方法 this(参数);

2. super
	A. 含义:
		当前对象的父类引用
	B. 用法:
		a. 成员变量 super.变量名称
		b. 成员方法 super.方法名称(参数);
		c. 构造方法 super(参数);

画图说明

第四章 final关键字

第01节 基础理论

final 关键字的含义:
	final 翻译成为中文： 最终的、最后的。不可以改变的。

final 有什么作用呢?
	A. 修饰类： 表示的是最终的类。没有子类，下面所有的方法，都不可以被重写。
	B. 修饰方法：表示的是最终的方法。这个方法不可以被重写。
	C. 修饰变量：表示的是当前的变量，值不可以改变。是常量。

第02节 案例代码

final 修饰类的情况

例如：我们java当中的字符串类 String 就是被 final 修饰。字符串没有子类，所有的方法都不可以被重写。

---

final修饰方法的情况

如果后期：想要实现当前类里面 某个方法不要被重写，其他的方法，还是可以被重写的情况。

这里就可以将 该方法，设置 final 修饰，其他方法还是可以被重写的。

---

final 修饰变量的情况

修饰的是 基本数据类型，如果是基本数据类型，表示的是 值不能变。

修饰的是 引用数据类型，如果是引用数据类型，表示的是 地址值 不能变。