【Java】Java面向对象之封装、继承、多态
一、封装
定义：封装就是将同一类事物的特性与功能包装在一起，对外暴露调用的接口。
封装可以可以被认为是一个保护屏障，防止该类的代码和数据被外部定义的代码随机访问。并且封装的主要功能在于我们能够修改自己实现的代码，而不用修改哪些调用我们代码的程序片段。
适当的封装可以让我们的代码更容易理解和维护，也加强了代码的安全性。
封装的优点：
1）解耦
2）类内部的结构可以自由修改
3）对成员变量进行 更精确的控制
4）隐藏信息，实现细节。
封装的实现步骤：
==》修改属性的可见性（设为private）
==》创建getter/setter方法（用于属性的读写）
==》在getter/setter方法中加入属性控制语句（对属性值进行合法性的判断）
package EncapsulationDemo;/*
* @author :James
* @date :2020/6/28 14:56
* @Email :[email protected]
* Version :V1.0
* @Function :
*/
public class People {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
if (name.length()>10){
System.out.println("长度过长，请重新输入");
}else{
this.name = name;
}
}
}
运行结果：
二、继承
概念：继承是子类继承父类的特征和行为，使得子类对象（实例）具有和父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为
生活中的继承：
上图继承关系可以了解到：动物属于父类（或者说基类或超类），食草动物和食肉动物分别是动物的子类（或者说是派生类）。而食草动物和食肉动物分别是子类（派生类）兔子和羊。老虎和狮子的父类。
继承特点：
1）子类可以拥有父类的内容：（都有名称，有五官等等）。
2）子类可以拥有自己专有的内容。（食草动物吃草，就是食草动物专有的内容，食肉动物吃肉，就属于食肉动物专有的内容）
继承的特性
1）子类拥有父类非private的属性、方法
2）子类可以拥有自己的属性和方法，也就是说子类可以对父类进行扩展
3）子类用自己的方式实现父类的方法
4）继承是单继承，也可以是多重继承，但是不能是多继承
5）提高了类的耦合性
关于单继承、多级继承图示：
在继承关系中，如果成员变量重名，则在创建子类对象的时候，有两种访问方式。
1）直接通过子类对象访问成员变量（等号左边是谁，就优先用谁，没有则向上找）
2）间接通过成员方法访问成员变量（该方法属于谁，就优先用谁，没有则向上找）
如何区分子类方法中重名的三种变量？
--》局部变量：直接写成员变量名
--》本类中的成员变量：this.成员变量名
--》父类中的成员变量名：super.成员变量名
【详细例子参照下面的代码：】
继承关键字：Java中使用extends和implements来实现继承，前者多用于类与类之间后者用于类与接口之间的继承。
public class Fu {
String father="Father";
int num=12;
public void methodFu(){
System.out.println("我是父类的方法");
}
}public class Zi extends Fu{
String son="Son";
int num=345;
public void methodZi(){
int num=123;
System.out.println("我是子类方法");
System.out.println(this.num ); //输出结果：345
System.out.println(super.num ); //输出结果：12
System.out.println(num ); //输出结果：10
}
}public class DemoExtends {
public static void main(String[] args) {
Zi zi=new Zi();
zi.methodZi(); //输出结果：这是子类的方法
zi.methodFu(); //输出结果：这是父类的方法
System.out.println(zi.son); //输出结果：Son
System.out.println(zi.father);//输出结果：Father
System.out.println(zi.num); //输出结果：34535
}
}关于成员变量、局部变量和类变量：
类变量（静态变量）：用static修饰的变量成为静态变量，其内容被该类所有对象共享，所有对象中的这个类变量的值都指向相同的一处内存，随便一个对象修改了此处内存的值都会影响其他对象。
成员变量：定义在方法外部，直接写在类当中，整个类都可以调用，如果没有赋值则会有一个默认值，规则和数组一样，成员变量位于堆内存当中。成员变量随着对象的创建而诞生，随着对象的回收而消失
局部变量：定义在方法内部，只有方法中才可以调用，除了方法就不能调用了，局部变量没有默认值，如果想要使用，必须手动进行赋值，其位于栈内存当中。局部变量随着方法进栈而诞生，随着方法出栈而消失 。
关于继承过程中的重写：
重写（override）：方法名称一样，参数列表也一样。
重载（overload）：方法名称一样，参数列表不一样。
注意事项：
1）必须保证父子类之间的方法的名称相同，参数列表也相同，@override：写在方法前面，用来检测是不是有效的正确覆盖重写，
2）子类方法的返回值必须【小于等于】父类方法的返回值范围。
3）子类方法的权限必须【大于等于】父类方法的权限修饰符。
重写应用场景：
public class Fu {
String father="Father";
int num=12;
public void methodFu(){
System.out.println("我是父类的方法");
}
}public class Zi extends Fu{
@Override
public void methodFu() {
System.out.println("覆盖了父类的方法");
}
}public class DemoExtends {
public static void main(String[] args) {
Zi zi=new Zi();
zi.methodFu(); //输出结果：覆盖了父类的方法
}
}三、多态
多态是同一个行为具有多个不同的表现形式或者形态的能力。多态存在的三个必要条件：
1）继承 2）重写 3）父类引用指向子类对象
多态的优点：
1）消除类型之间的耦合关系 2）可替换性 3）接口性
4）灵活性 5）简化性 6）可扩充性
多态实例：
--》接口
public interface InterfaceUSB {
public abstract void powerOn();
public abstract void powerOff();
}--》两个实现类
public class KeypressInterface implements InterfaceUSB{
@Override
public void powerOn() {
System.out.println("键盘已连接");
}
@Override
public void powerOff() {
System.out.println("键盘已断开");
}
public void type(){
System.out.println("键盘输入");
}
}public class MouseInterface implements InterfaceUSB{
@Override
public void powerOn() {
System.out.println("连接鼠标");
}
@Override
public void powerOff() {
System.out.println("关闭鼠标");
}
public void click (){
System.out.println("鼠标点击");
}
}--》主体代码
public class Computer {
public void powerOn() {
System.out.println("开机已就绪");
}
public void powerOff() {
System.out.println("已关机");
}
//使用USB设备方法，使用接口作为方法的参数
public void useDevice(InterfaceUSB interfaceUSB) {
interfaceUSB.powerOn();
if (interfaceUSB instanceof MouseInterface) { // 一定要先判断
MouseInterface mouse = (MouseInterface) interfaceUSB; // 向下转型
mouse.click();
} else if (interfaceUSB instanceof KeypressInterface) { // 先判断
KeypressInterface keyboard = (KeypressInterface) interfaceUSB; // 向下转型
keyboard.type();
}
interfaceUSB.powerOff();
}
}public class ComputerMain {
public static void main(String[] args) {
//创建一个笔记本电脑
Computer computer=new Computer();
computer.powerOn();
//准备一个鼠标供电脑使用
MouseInterface mouseInterface=new MouseInterface();
computer.useDevice(mouseInterface);
//创建一个USB键盘
KeypressInterface keypressInterface=new KeypressInterface();
computer.useDevice(keypressInterface);
computer.powerOff();
}
}
运行结果：
此多态例子中，KeypressInterface和Mouseinterface实现了InterfaceUSB接口，并且除了实现了powerOn和powerOff方法外还都有各自的方法【keypressInterface的键入方法，MouseInterface的点击方法】，并且在代码中又出现了两个新的知识点，对象的向上转型和向下转型
对象的向上、向下转型
1）对象的向上转型，其实就是多态的写法
格式：父类名称 对象名=new 子类名称 (); InterfaceUSB interfaceMouse=new MouseInterface();
含义：右侧创建一个子类对象，把它当做父类来看待使用 【上面代码：创建一个鼠标当接口使用】
2）对象的向下转型，实际则为一个【还原】的动作
注意：【向下转型，需要使用instanceof进行判断，防止出现ClassCastException(类转换异常)错误】
格式 ：子类名称 对象名=（子类名称）父类对象；含义：将父类对象，【还原】成为本来的子类对象
参考链接：
https://www.cnblogs.com/hysum/p/7100874.html
https://www.cnblogs.com/nongzihong/p/10494453.html
https://www.cnblogs.com/ygj0930/p/10830957.html