JAVA基础加强篇02——面向对象三大特征

JAVA基础加强篇02——面向对象三大特征

面向对象三大特征之一：封装

封装思想概述

封装

• 面向对象的三大特性： 封装、继承、多态。
• 封装：告诉我们，如何正确设计对象的属性和方法。
• 封装的原则： 对象代表什么，就得封装对应的数据，并提供数据对应的行为。

理解封装思想有啥好处？

• 有什么事，找对象，调方法就行，编程变得很简单。
• 降低我们的学习成本，可以少学、少记。

总结

1. 什么是封装啊？
   • 告诉我们，如何正确设计对象的属性和方法。
   • 原则： 对象代表什么，就得封装对应的数据，并提供数据对应的行为。
2. 理解封装思想有什么好处？
   • 让编程变得和简单，有什么事，找对象，调方法就行。
   • 降低我们的学习成本，可以少学、少记，或者压根不用学，不用记对象的那么多方法，有需要时去找就行。

如何更好的封装

• 一般建议对成员变量使用 private（私有、隐藏）关键字修饰进（ private 修饰的成员只能在当前类中访问）。

• 为每个成员变量提供配套 public 修饰的 getter、setter 方法暴露其取值和赋值。

总结

1. 如何进行更好的封装？
   • 一般会把成员变量使用 private 隐藏起来，对外就不能直接访问了。
   • 提供 public 修饰的 getter 和 setter 方法暴露其取值和赋值。

面向对象三大特征之二：继承

继承概述、使用继承的好处

什么是继承?

• Java 中提供一个关键字 extends，用这个关键字，我们可以让一个类和另一个类建立起父子关系。

• Student 称为子类（派生类），People称为父类（基类 或超类）。

• 作用：当子类继承父类后，就可以直接使用父类公共的属性和方法了。

使用继承的好处

• 可以提高代码的复用性。

案例练习：请阅读以下代码存在的问题，并使用继承这个技术进行优化

总结

1. 什么是继承？继承的好处是啥？
   • 继承就是 java 允许我们用 extends 关键字，让一个类和另一个类建立起一种父子关系。
   • 提高代码复用性，减少代码冗余，增强类的功能扩展性。
2. 继承的格式
   • 子类 extends父类
3. 继承后子类的特点？
   • 子类 继承父类，子类可以得到父类的属性和行为，子类可以使用。
   • Java 中子类更强大

继承的设计规范、内存运行原理

继承设计规范：

• 子类们相同特征（共性属性，共性方法）放在父类中定义，子类独有的属性和行为应该定义在子类自己里面。

为什么？

• 如果子类的独有属性、行为定义在父类中，会导致其它子类也会得到这些属性和行为，这不符合面向对象逻辑。

案例 继承的设计规范

需求：

• 在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。

分析：

• 学生信息和行为（名称，年龄，所在班级，查看课表，填写听课反馈）
• 老师信息和行为（名称，年龄，部门名称，查看课表，发布问题）
• 定义角色类作为父类包含属性（名称，年龄），行为（查看课表）
• 定义子类：学生类包含属性（所在班级），行为（填写听课反馈）
• 定义子类：老师类包含属性（部门名称），行为（发布问题）

内存运行原理图

总结

1. 继承需要满足什么样的设计规范？
   • 子类们相同特征（共性属性，共性方法）放在父类中定义。
   • 子类独有的属性和行为应该定义在子类自己里面。

继承的特点

1. 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
2. Java 是单继承模式：一个类只能继承一个直接父亲。
3. Java 不支持多继承、但是支持多层继承。
4. Java 中所有的类都是 Object 类的子类。

详解

1、子类是否可以继承父类的构造器？

• 不可以的，子类有自己的构造器，父类构造器用于初始化父类对象。

2、子类是否可以继承父类的私有成员？

• 可以的，只是不能直接访问。
• 生活例子：你父亲给了你一个保险箱，你继承了，只是不知道密码。

3、子类是否可以继承父类的静态成员？

• 有争议的知识点。
• 子类可以直接使用父类的静态成员（共享）
• 但个人认为：子类不能继承父类的静态成员。（共享并非继承）

4、Java 只支持单继承，不支持多继承

• 为什么不支持多继承？

5、Java 支持多层继承

6、Object特点：

• Java 中所有类，要么直接继承了 Object，要么默认继承了 Object，要么间接继承了 Object，Object是祖宗类。

总结

1. 继承有哪些特点？
   • 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器。
   • Java 是单继承模式：一个类只能继承一个直接父类。
   • Java 不支持多继承，但是支持多层继承。
   • Java 中所有的类都是 Object 类的子类。

继承后：成员变量、成员方法的访问特点

在子类方法中访问成员（成员变量、成员方法）满足：就近原则

• 先子类局部范围找
• 然后子类成员范围找
• 然后父类成员范围找，如果父类范围环没有找到则报错。

如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？

• 可以通过，super关键字，指定访问父类的成员

总结

1. 在子类方法中访问成员（成员变量、成员方法）满足：

   • 就近原则，子类没有找子类、子类没有找父类、父类没有则报错！

2. 如果子父类中出现了重名的成员，此时如果一定要在子类中使用父类的怎么办？

继承后：方法重写

什么是方法重写？

• 在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。

方法重写的应用场景

• 当子类需要父类的功能，但父类的该功能不完全满足自己的需求时。
• 子类可以重写父类中的方法。

案例演示：

• 旧手机的功能只能是基本的打电话，发信息。
• 新手机的功能需要能够：基本的打电话下支持视频通话。基本的发信息下支持发送语言和图片。

Override 重写注解

• @Override 是放在重写后的方法上，作为重写是否正确的校验注解。
• 加上该注解后如果重写错误，编译阶段会出现错误提示。
• 建议重写方法都加 @Override 注解，代码安全，优雅！

方法重写注意事项和要求

• 重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
• 私有方法不能被重写。
• 子类重写父类方法时，访问权限必须大于或者等于父类（暂时了解：缺省 < protected < public）
• 子类不能重写父类的静态方法，如果重写会报错的。

总结

1. 方法重写是什么样的？
   • 子类写一个与父类申明一样的方法覆盖父类的方法。
2. 方法重写建议加上哪个注解，有什么好处？
   • @Override 注解可以校验重写是否正确，同时可读性好。
3. 重写方法有哪些基本要求？
   • 重写方法的名称和形参列表应该与被重写方法一致。
   • 私有方法不能被重写。
   • 子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限。
   • 子类不能重写父类的静态方法，如果重写会报错的。

继承后：子类构造器的特点

子类继承父类后构造器的特点：

• 子类中所有构造器默认都会先访问父类中无参的构造器，在执行自己。

为什么？

• 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
• 子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

怎么调用父类构造器的？

• 子类构造器的第一行语句默认都是：super()，不写已存在。

总结

1. 子类继承父类后构造器的特点是什么样的？
   • 子类中所有的构造器默认都会先访问父类中无参的构造器，在执行自己。

继承后：子类构造器访问父类有参构造器

super调用父类有构造器的作用：

• 初始化继承自父类的数据。

//调用
/*** 目标：学习子类构造器如何去访问父类有参构造器，还要清楚其作用。*/
public class Test {public static void main(String[] args) {Teacher teacher = new Teacher("张三", 18);System.out.Name());System.out.Age());}
}

/**
* 父类
*/
public class People {private String name;private int age;public People(){}public People(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 Teacher extends People{public Teacher(){ }public Teacher(String name,int age){//调用父类的有参构造器，初始化继承自父类数据super(name,age);}

如果父类中没有无参构造器，只有有参构造器，会出现什么现象呢？

• 会报错。因为子类默认是调用父类无参构造器的。

如何解决？

• 子类构造器中可以通过书写 super(…)，手动调用父类的有参构造器。

总结

1. super 调用父类构造器的作用是什么？
   • 通过调用父类有参数构造器来初始化继承自父类的数据

this、super使用总结

this 和 super 详情

• this：代表本类对象的应用；super：代表父类存储空间的标识。

• 实际上，在以上的总结中，唯独只有 this 调用本类其他构造器我们是没有接触过的。

案例需求：

• 在学员信息登记系统中，后台创建对象封装数据的时候如果用户没有输入学习，则默认使用"黑马培训中心"。

• 如果用户输入了学校则使用用户输入的学校信息。

  /*** 目标：理解 this(…) 和 super(…) 的作用：本类构造器中访问本类兄弟构造器。*/
  public class Test {public static void main(String[] args) {Student sl = new Student("易苏苏","冰火岛自学");System.out.Name());System.out.SchoolName());Student s2= new Student("张三丰");System.out.Name());System.out.SchoolName());}
  }
  

  public class Student {private String name;private String schoolName;public Student() {}/*** 如果学生不填写学校，默认这对象的学校是黑马* @param name*/public Student(String name){// 借用本类兄弟构造器this(name,"黑马培训机构");}public Student(String name, String schoolName) {this.name = name;this.schoolName = schoolName;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getSchoolName() {return schoolName;}public void setSchoolName(String schoolName) {this.schoolName = schoolName;}
  }
  

this(…) 和 super(…) 使用注意点：

• 子类通过 this(…) 去调用本类的其他构造器，本类其他构造器会通过 super 去手动调用父类的构造器，最终还是会调用父类构造器的。
• 注意：this(…) super(…) 都只能放在构造器的第一行，所以二者不能共存在同一个构造器中。

面向对象三大特征之三：多态

多态的概述，多态的形式

什么是多态？

• 同类型的对象，执行同一个行为，会表现出不同的行为特征。

多态的常见形式

多态中成员访问特点

• 方法调用：编译看左边，运行看右边。

• 变量调用：编译看左边，运行也看左边。（多态侧重行为为多态）

  public abstract class Animal {public String name = "父类动物";public abstract void run();
  }public class Dog extends Animal{public String name = "子类狗";@Overridepublic void run() {System.out.println("狗跑的的贼快！");}
  }public class Tortoise extends Animal{public String name = "子类乌龟";@Overridepublic void run() {System.out.println("乌龟根本跑不了！");}
  }
  

  /*** 目标：认识多态，理解多态的形式和概念*/
  public class Test {public static void main(String[] args) {Animal a = new Dog();a.run();//方法：编译看左边，运行看右边System.out.println(a.name);//对于变量的调用：编译看左，运行也看左Animal t = new Tortoise();t.run();//方法：编译看左边，运行看右边System.out.println(t.name);//对于变量的调用：编译看左，运行也看左}
  }
  

多态的前提

• 有继承/实现关系；有父类引用指向子类对象；有方法重写。

多态的优势

优势

• 在多态形势下，右边对象可以实现解耦合，便于扩展和维护。

• 定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利。

多态下回产生的一个问题：

• 多态下不能使用子类的独有功能

/*** 父类*/
public class Animal {public String name = "动物名称";public void run(){System.out.println("动物可以跑~");}
}public class Dog extends Animal{public String name = "狗名称";@Overridepublic void run(){System.out.println("狗跑的贼溜~");}/*** 独有功能*/public void lookDoor(){System.out.println("狗在看门~");}
}public class Tortoise extends Animal{public String name = "乌龟名称";@Overridepublic void run(){System.out.println("乌龟跑的非常慢~");}
}

/*** 目标：多态的优势*/
public class Test {public static void main(String[] args) {Animal t = new Tortoise();go(t);Animal d = new Dog();go(d);
//        d.lookDoor();// 多态下不能访问子类独有功能}public static void go(Animal a){System.out.println("开始~~~~");a.run();System.out.println("结束~~~~");}
}

多态下引用数据类型的类型转换

自动类型转化（从子到父）：子类对象赋值给父类类型的变量指向。

强制类型转换吗（从父到子）:

• 此时必须进行强制类型转换：子类 对象变量 = （子类）父类类型的变量

• 作用：可以解决多态下的劣势，可以实现调用子类独有的功能。

• 注意：如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException

• Java 建议强转转换前使用 instanceof 判断当前对象的真实类型，再进行强制转换

public class Animal {public void run(){System.out.println("动物可以跑~");}
}public class Dog extends Animal{public void run(){System.out.println("狗跑的贼溜~");}public void lookDoor(){System.out.println("狗在看门~");}
}public class Tortoise extends Animal{public void run(){System.out.println("乌龟跑的很慢~");}public void layEggs(){System.out.println("乌龟可以下蛋~");}
}

/*** 目标：学习多态形势下的类中转换机制。*/
public class Test {public static void main(String[] args) {//自动类型转换：Animal dog = new Dog();dog.run();//强制类型转换Animal tortoise = new Tortoise();tortoise.run();//        Dog d = (Dog) tortoise;//强制类型转换，编译阶段不报错的（注意：有继承或者实现关系编译阶段可以强制，没有毛病），运行时可能出错的！if (tortoise instanceof Tortoise){Tortoise t = (Tortoise) tortoise;//从父类类型到子类类型，必须强制类型转换t.layEggs();}else if (tortoise instanceof Dog){Dog d = new Dog();d.lookDoor();}System.out.println("----------------------");go(new Dog());go(new Tortoise());}public static void go(Animal a){a.run();if (a instanceof Tortoise){Tortoise t = (Tortoise) a;//从父类类型到子类类型，必须强制类型转换t.layEggs();}else if (a instanceof Dog){Dog d = new Dog();d.lookDoor();}}
}

总结

1. 引用数据类型的类型转换，有几种方式？
   • 自动类型转换、强制类型转换。
2. 强制类型转换能解决什么问题？强制类型转换需要注意什么。
   • 可以转换成真正的子类类型，从而调用子类独有功能。
   • 有继承关系/实现的 2 个类型就可以进行强制转换，编译无问题。
   • 运行时，如果发现强制转换后的类型不是对象真实类型则报错。

多态的综合案例

需求：

• 使用面向对象编程模拟：设计一个电脑对象，可以安装 2 个 USB设备
• 鼠标：被安装时可以完成接入、调用点击功能、拔出功能。
• 键盘：被安装时可以完成接入、调用打字功能、拔出功能。

分析：

1. 定义一个 USB 的接口（申明 USB 设备的规范必须是：可以接入和拔出）。
2. 提供 2 个 USB实现类代表鼠标和键盘，让其实现USB接口，并分别定义独有功能。
3. 创建电脑对象，创建 2 个USB 实现类对象，分别安装到电脑中并触发功能的执行。

/*** USB接口 == 规范*/
public interface USB {//接入 拔出void connect();void unconnet();
}public class KeyBoard implements USB{private String name;public KeyBoard(String name) {this.name = name;}@Overridepublic void connect() {System.out.println(name + "成功连接了电脑~");}/*** 独有功能*/public void keyDown(){System.out.println(name + "敲击了：来了，老弟，666……没毛病~");}@Overridepublic void unconnet() {System.out.println(name + "成功从电脑中拔出了~");}public String getName() {return name;}public void setName(String name) {this.name = name;}
}public class Computer {private String name;public Computer(String name) {this.name = name;}public void start(){System.out.println(name + "开机了~");}/*** 提供安装 USB 设备的入口*/public void installUSB(USB usb){// 多态： usb == 可能是鼠标 也可能是键盘t();//独有功能 ： 先判断再强转if (usb instanceof KeyBoard){KeyBoard keyBoard = (KeyBoard) usb;keyBoard.keyDown();}else if (usb instanceof Monse){Monse monse = (Monse) usb;monse.dbClick();}usb.unconnet();}public String getName() {return name;}public void setName(String name) {this.name = name;}
}public class Monse implements USB{private String name;public Monse(String name) {this.name = name;}@Overridepublic void connect() {System.out.println(name + "成功连接了电脑~");}/*** 独有功能*/public void dbClick(){System.out.println(name + "双击点亮小红心，一键三连~");}@Overridepublic void unconnet() {System.out.println(name + "成功从电脑中拔出了~");}public String getName() {return name;}public void setName(String name) {this.name = name;}
}public class Computer {private String name;public Computer(String name) {this.name = name;}public void start(){System.out.println(name + "开机了~");}/*** 提供安装 USB 设备的入口*/public void installUSB(USB usb){// 多态： usb == 可能是鼠标 也可能是键盘t();//独有功能 ： 先判断再强转if (usb instanceof KeyBoard){KeyBoard keyBoard = (KeyBoard) usb;keyBoard.keyDown();}else if (usb instanceof Monse){Monse monse = (Monse) usb;monse.dbClick();}usb.unconnet();}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

/***  目标： USB设备模拟*  1、定义 USB 接口：接入 拔出*  2、定义2个USB的实现类：鼠标、键盘*  3、创建一个电脑对象，创建USB设备对象，安装启动*/
public class Test {public static void main(String[] args) {// a、创建电脑对象Computer computer = new Computer("外星人");computer.start();// b、创建鼠标对象，键盘对象USB u = new KeyBoard("双飞燕");computer.installUSB(u);USB u1 = new Monse("罗技鼠标");computer.installUSB(u1);}
}