Java三大特性：封装、继承、多态
封装
定义
该露的露，该藏的藏
- 我们程序设计要追求"高内聚，低耦合"。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
封装(数据的隐藏)
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
记住这句话就够了：属性私有，get/set
封装意义和作用
- 提高程序的安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 增加系统可维护性
/*
封装意义作用：
1. 提高程序的安全性
2. 保护数据
3. 统一接口
4. 系统可维护性增加
*/
// 类 private :私有
public class Student {
//属性私有
private String name; //名字
private int id; //学号
private char sex; //性别
private int age;
//提供一些可以操作这个属性的方法
// 提供一些public 的 get 、 set 方法
// Alt + Insert
//get 获得这个数据
public String getName(){
return this.name;
}
//set 给这个数据设置值
public void setName(String name){
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>150||age<0){ //不合法
this.age = 3;
}else {
this.age = age;
}
}
}
//测试类
/*
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("qinjiang");
String name = s1.getName();
System.out.println(name);
s1.setAge(999); //年龄999不合法的
System.out.println(s1.getAge());
}
*/
继承
什么是继承
java种提供了一个关键字 extends ， 用这个关键字，我们可以昂一个类和另一个类建立起父子关系。
public class Student extends People{}
Student 成为子类(派生类)，People 成为父类(基类或超类)
作用
当子类继承父类后，就可以直接使用父类公共的属性和方法了
好处
- 可以提高代码的复用性，
- 减少代码冗余，
- 增强类的功能扩展性
基本特点
- 子类继承父类，子类可以得到父类的属性和行为，子类可以使用
- Java中子类更强大
继承设计规范
子类们相同特征(共性属性，共性方法)放在父类种定义，子类独有的属性和行为应该定义在子类自己里面
原因
如果子类的独有属性、行为定义在父类中，会导致其它子类也会得到这些属性和行为，这不符合面向对象逻辑思想。
案例
内存运行原理
继承的特点
- 子类可以继承父类的属性和行为，但是子类不能继承父类的构造器
- Java是单继承模式：一个类只能能继承一个直接的父类
- Java不支持多继承，但是支持多层继承。
- Java种所有的类都是Object类的子类(Object类是祖宗类，Java中所有类，要么直接继承了Object，要么默认继承了Object，要么间接继承了Object)
继承后：成员变量、成员方法的访问特点
在子类方法中访问成员变量、成员方法满足：就近原则
- 先子类局部范围找
- 然后子类成员范围找
- 然后父类成员范围找，如果父类范围还没有找到则报错
public class Test {
public static void main(String[] args) {
// 目标：理解继承后成员的访问特点：就近原则
Dog dog = new Dog();
dog.run();
dog.lookDoor();
dog.showName();
}
}
class Animal{
public String name = "动物们";
public void run(){
System.out.println("动物可以跑");
}
}
class Dog extends Animal{
public String name = "狗名";
public void lookDoor(){
System.out.println("狗可以看门");
}
public void showName(){
String name = "局部名";
System.out.println(name);
System.out.println(this.name);//当前子类对象的name
System.out.println(super.name);//找父类的name
run();//子类的run
super.run();//父类的方法
}
public void run(){
System.out.println("狗可以跑，贼快！");
}
}
继承后：方法重写
定义
在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称这个方法是重写的方法。
方法重写的应用场景
- 当子类需要父类的功能，但父类的该功能不完全满足自己的需求时
- 子类可以重写父类中的方法
案例演示
public class Test {
public static void main(String[] args) {
// 目标：认识方法重写
NewPhone newPhone = new NewPhone();
newPhone.call();
newPhone.sendMsg();
}
}
public class Phone {
public void call(){
System.out.println("打电话");
}
public void sendMsg(){
System.out.println("发短信");
}
}
public class NewPhone extends Phone{
@Override //1.重写校验注解，加上之后，这个方法必须时正确重写的，这样更安全 2.提高程序的可读性，代码更优雅
public void call(){
super.call();
System.out.println("开始视频通话");
}
@Override
public void sendMsg(){
super.sendMsg();
System.out.println("发送有趣的图片");
}
}
@Override重写注解
- @Override 是放在重写后的方法上，作为重写是否正确的校验注解
- 加上该注解后，如果重写错误，编译阶段会出现错误提示
- 建议重写方法都加上 @Override 注解，代码安全，优雅！
方法重写注意事项和要求
- 重写方法的名称、形参列表必须和被重新的名称、形参列表一致！(声明不变，重新实现)
- 私有方法不能被重写
- 子类不能重写父类的静态方法，如果重写会报错
- 子类重写父类方法时，访问权限必须大于或等于父类
继承后：子类构造器的特点
子类中所有的构造器默认都会先访问父类中无参的构造器，在执行自己
原因
- 子类在初始化的适合，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据
- 子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。
如何调用父类构造器？
子类构造器的第一行语句默认都是： super() ; 不写也存在
public class Test {
public static void main(String[] args) {
// 目标：认识继承后子类构造器的特点
// 热点：子类的全部构造器默认会先访问父类的无参构造器在执行自己
Dog dog = new Dog();
System.out.println(dog);
Dog dog2 = new Dog("金毛");
System.out.println(dog2);
}
}
public class Animal {
public Animal(){
System.out.println("父类Animal无参构造器被执行");
}
}
public class Dog extends Animal{
public Dog(){
System.out.println("子类Dog无参构造器被执行");
}
public Dog(String name){
System.out.println("子类Dog有参构造器被执行");
}
}
继承后：子类构造器访问父类有参构造器
public class Test {
public static void main(String[] args) {
// 目标：学习子类构造器如何去访问父类有参构造器，还要清楚其作用
Teacher teacher = new Teacher("张三",23);
System.out.println(teacher);
}
}
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);
}
}
this、super使用总结
this和super详情
- this ：代表本类对象的引用
- super ： 代表父类存储空间的标识
案例
测试类
public class Test {
public static void main(String[] args) {
// 目标：理解this(...)的作用：本类构造器中访问本类兄弟构造器
Student s1 = new Student("殷素素","冰火岛自学");
System.out.println(s1.getName());
System.out.println(s1.getSchoolName());
//如果学生不填写学校，默认学校为 黑马
Student s2 = new Student("张三丰");
System.out.println(s2.getName());
System.out.println(s2.getSchoolName());
}
}
学生类
public class Student {
private String name;
private String schoolName;
public Student() {
}
/*
如果学生不填写学校，默认学校为 黑马
*/
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= "子类狗";
@Override
public void run() {
System.out.println("🐕跑的贼快~~~");
}
}
public class Tortoise extends Animal{
public String name= "子类乌龟";
@Override
public void run() {
System.out.println("乌龟跑不动~~");
}
}
public class Test {
public static void main(String[] args) {
// 1.多态的形式 父类类型 对象名称 = new 子类构造器;
Animal d = new Dog();
d.run(); //编译看左边，运行看右边
System.out.println(d.name); //对于变量的调用编译看左边，运行也看左边
Animal t = new Tortoise();
t.run();
System.out.println(t.name);
}
}
多态的优势
优势
- 在多态形式下，右边对象可以实现解耦合，便于扩展和维护
- 定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子对象，体现处多态的扩展性与便利
多态下会产生的一个问题：
多态下不能使用子类的独有功能
public abstract class Animal {
public String name = "父类动物";
public abstract void run();
}
public class Tortoise extends Animal {
public String name= "子类乌龟";
@Override
public void run() {
System.out.println("乌龟跑不动~~");
}
}
public class Dog extends Animal {
public String name= "子类狗";
@Override
public void run() {
System.out.println("🐕跑的贼快~~~");
}
/**
* 独有功能
*/
public void lookDoor(){
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 String name = "父类动物";
public void run() {
System.out.println("动物可以跑~");
}
}
public class Dog extends Animal {
@Override
public void run() {
System.out.println("🐕跑的贼快~~~");
}
/**
* 独有功能
*/
public void lookDoor(){
System.out.println("狗在看门！");
}
}
public class Tortoise extends Animal {
@Override
public void run() {
System.out.println("乌龟跑不动~~");
}
/**
* 独有功能
*/
public void layEggs(){
System.out.println("乌龟在下蛋~~");
}
}
/**
* 目标 ：学习多态形式下的类中转换机制
*/
public class Test {
public static void main(String[] args) {
//自动类型转换(从子到父) ：子类对象赋值给父类类型的变量指向
Animal a = new Dog();
a.run();
//强制类型转换(从父到子)：
Animal a2 = new Tortoise();
a2.run();
//Dog t = (Dog) a2; //强制类型转换，编译阶段不报错的（注意：有继承或者实现关系编译阶段可以强转，没有毛病）运行时可能出错
go(new Dog());
go(new Tortoise());
}
public static void go(Animal a){
// a 到底是乌龟还是狗？
if (a instanceof Tortoise){
Tortoise t = (Tortoise) a; //从父类类型到子类类型，必须强制类型转换
t.layEggs();
} else if (a instanceof Dog) {
Dog d = (Dog) a;
d.lookDoor();
}
}
}
多态的案例
/**
* USB接口 == 规范
*/
public interface USB {
// 接入 拔出
void connect();
void unconnect();
}
/*
鼠标实现类
*/
public class Mouse implements USB{
private String name;
@Override
public void connect() {
System.out.println(name + "成功连接了电脑~");
}
/**
* 独有功能
*/
public void dbClick(){
System.out.println(name+ "点击了按键");
}
@Override
public void unconnect() {
System.out.println(name+"成功从电脑中拔出~");
}
public Mouse() {
}
public Mouse(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/*
键盘实现类
*/
public class KeyBoard implements USB{
private String name;
@Override
public void connect() {
System.out.println(name + "成功连接了电脑~");
}
@Override
public void unconnect() {
System.out.println(name+"成功从电脑中拔出~");
}
/**
* 独有功能
*/
public void keyDown(){
System.out.println(name+ "敲击了按键");
}
public KeyBoard() {
}
public KeyBoard(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
/*
电脑类
*/
public class Computer {
private String name;
public Computer() {
}
public Computer(String name) {
this.name = name;
}
public void start(){
System.out.println(name+"电脑开机了");
}
/*
提供安装USB设备的入口
*/
public void installUSB(USB usb){
//多态： usb == 可能是鼠标 也可能是键盘
usb.connect();
//独有功能:先判断，在强转
if (usb instanceof KeyBoard){
KeyBoard k = (KeyBoard) usb;
k.keyDown();
}else if (usb instanceof Mouse){
Mouse m = (Mouse) usb;
m.dbClick();
}
usb.unconnect();
}
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 c = new Computer("外星人");
c.start();
// b.创建鼠标对象，键盘对象
USB k = new KeyBoard("双飞燕");
c.installUSB(k);
USB m = new Mouse("罗技鼠标");
c.installUSB(m);
}
}
浙公网安备 33010602011771号