学习:JAVASE_6 封装/继承/多态-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_58228816/article/details/145062909

封装

封装概述:
- 是面向对象三大特征之一(封装,继承,多态)
- 是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作的
封装原则:
- 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private ,提供对应的getXxx()/setXxx()方法
封装的好处:
- 通过方法来控制成员变量的操作,提高了代码的安全性
- 把代码用方法进行封装,提高了代码的复用性

private关键字

是一个权限修饰符
可以修饰成员(成员变量和成员方法)
作用是保护成员不被别的类使用,被private修饰的成员只能在本类中才能访问

提供get方法,用于获取成员变量的值,方法用public修饰
提供set方法,用于设置成员变量的值,方法用public修饰

public class PrivateVariable {
    private String name;

    public String getName() {
        return name;
    }

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

this关键字

this修饰的变量用于指代成员变量
- 方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量
- 方法的形参没有与成员变量同名,不带this修饰的变量指的是成员变量
this关键字主要是用来解决局部变量隐藏成员变量的状况
this:代表所在类的对象引用
- 记住: 方法被哪个对象调用,this就代表哪个对象

构造方法

作用:
- 创建对象
功能:
- 主要是完成对象数据的初始化
注意事项:
- 构造方法的创建:
  - 如果没有定义构造方法,系统将给出一个默认的无参数构造方法
  - 如果定义了构造方法,系统将不再提供默认的构造方法
- 构造方法的重载:
  - 如果自定义了带参构造方法,还要使用无参数构造方法,就必须再写一个无参数构造方法
- 推荐的使用方式:
  - 无论是否使用,都手工书写无参数构造方法

// 格式:
public class 类名 {
	修饰符 类名(参数) {
	}
}
public class ConstructionMethod {
    private String name;
    public ConstructionMethod() {
        System.out.println("无参构造方法");
    }

    public ConstructionMethod(String name) {
        this.name = name;
    }
}
// 在创建对象的时候就会被调用
// 测试类
public class TestClass {
    public static void main(String[] args) {
        ConstructionMethod constructionMethod = new ConstructionMethod();
      	// 创建对象的时候就会调用对应的带参和无参构造方法
        ConstructionMethod takeGinsengStructure = new ConstructionMethod("zml");
    }
}

继承

查看类的继承体系:idea快捷键 ctrl + h

特点:子类可以直接使用父类所有非私有的属性和行为!~ ==私有属性需要调用get和set方法间接使用==
Java只支持单继承, 不支持多继承, 但是支持多层继承.构造方法不继承
好处
- 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
- 提高了代码的维护性(如果方法的代码需要修改,修改一处即可)
弊端
- 继承让类与类之间产生了关系,类的耦合性增强了,当父类发生变化时子类实现也不得不跟着变化,削弱了子类的独立性

this和super

关键字	访问成员变量	访问构造方法	访问成员方法
this	this.成员变量:访问本类成员变量	this(...):访问本类构造方法	this.成员方法(...):访问本类成员方法
super	super.成员变量:访问父类成员变量	super(...):访问父类构造方法	super.成员方法(...):访问父类成员方法

继承中构造方法的访问特点

原因
- 因为子类会继承父类中的数据,可能还会使用父类的数据,所以,子类初始化之前,一定要先完成父类数据的初始化
- 每一个子类构造方法的第一条语句默认都是:super()
- 如果父类中只有带参构造方法,继承的子类需要手动在构造方法中添加父类的带参构造方法:super(...)

方法重写

应用场景:
- 当子类需要父类的功能,而功能主题子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容
注意事项:
- 在方法的重写中, 子类方法的权限可以==(必须)==大于等于父类~==子类方法的返回值必须<小于等于>父类方法的返回值范围. Public > 默认(什么都不写) > private
- 父类的私有方法是不可以被重写的

/**
 * 人类    父类,也被称为基类或超类
 * @author zml
 * @date 2021年11月07日19:54:45
 */
public class People {
    private String name;
    private String age;

    public People() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }
}
/**
 * 老师类     子类,也被称为派生类
 * @author zml
 * @date 2021年11月07日19:56:16
 */
public class Teacher extends People{
    public Teacher() {
    }

    public Teacher(String name, String age) {
        super(name, age);
    }
  
  	@Override   // 方法的重写建议使用快捷方式,直接写出父类的方法名,来带出需要重写的方法
    public void setName(String name) {
        super.setName(name);
    }

}

多态

多态的前提和体现

1,有继承/实现关系 2,有方法重写 3,有父类引用指向子类对象

多态的格式

定义时的多态

Fruit f = new Apple();

EatAble e = new Apple();

参数传递时的多态(多态存在的主要作用!!!)

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

public static void fun(Fruit f) {

}

方法返回值的多态

public static Fruit fun() {
    return new Apple();
}

多态中的成员访问特点
- 成员变量:编译看左边,执行看左边(编译和执行对看引用对象的)
- 成员方法:编译看左边,执行看右边(编译校验引用对象,而执行输出的是子类对象的)

多态的好处和弊端
- 多态的好处:提高了程序的扩展性
  - 具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作
- 多态的弊端:不能使用子类的特有功能

可能出现的问题

ClassCastException: 类型转换异常

解决方法: 对象 instanceof 类型:判断对象是否是该类型,得到boolean值

/**
 * 动物类
 * @author zml
 * @date 2021年11月09日22:27:50
 */
public abstract class Animal {
    /**
     * 动物吃饭的方法
     */
    public abstract void eat();
}
/**
 * 多态中的子类实现类
 * @author zml
 * @date 2021年11月09日22:31:12
 */
public class Cat extends Animal {
    @Override   
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void playGame() {
        System.out.println("测试多态向下转型用例");
    }
}
// 举例:猫
// 我们可以说猫是猫: Cat cat = new Cat();
// 我们也可以说猫是动物: Animal animal = new Cat();
// 这里猫在不同的时刻表现出来了不同的形态,这就是多态

/**
 * 动物操作类
 * @author zml
 * @date 2021年11月09日22:52:46
 */
public class AnimalOperator {
    public void useAnimal(Animal animal) {
        animal.eat();
    }
}

/**
 * 动物多态测试类
 * @author zml  
 * @date 2021年11月09日22:55:43
 */
public class AnimalTest {
    public static void main(String[] args) {
        AnimalOperator animalOperator = new AnimalOperator();
        animalOperator.useAnimal(new Cat());
      
      /*
      多态中的向上转型:
      		从子到父:父类引用指向子类对象
      多条中的向下转型:
      		从父到子:父类引用转为子类对象
      */
        Animal animal = new Cat();
        animal.eat();
      // instanceof 判断对象是否属于该类
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.playGame();
            ((Cat) animal).playGame();
        }
    }
}