订做网站和app,一元云购网站黑客攻击,wordpress耗资源关闭,成都网站建设_创新互联一、面向对象高级
此笔记参考黑马教程#xff0c;仅学习使用#xff0c;如有侵权#xff0c;联系必删 文章目录 一、面向对象高级1. static#xff08;静态#xff09;1.1 static 修饰成员变量1.1.1 static1.1.2 成员变量的执行原理总结 1.2 static 修饰成员变量的应用场…一、面向对象高级
此笔记参考黑马教程仅学习使用如有侵权联系必删 文章目录 一、面向对象高级1. static静态1.1 static 修饰成员变量1.1.1 static1.1.2 成员变量的执行原理总结 1.2 static 修饰成员变量的应用场景类变量的应用场景案例总结 1.3 static 修饰成员方法1.3.1 成员方法的分类1.3.2 成员方法的执行原理代码演示总结 补充知识搞懂 mian 方法1.4 static 修饰成员方法的应用场景1.4.1 类方法的常见应用场景1.4.2 工具类是什么1.4.3 使用类方法来设计工具类有啥好处案例代码实现 多学一招总结 1.5 static 的注意事项代码演示 1.6 static 的应用知识代码块1.6.1 代码块概述代码演示 1.7 static 的应用知识单例设计模块1.7.1 什么是设计模式Design pattern1.7.1.2 单例设计模式饿汉式单例1.7.1.3 单例模式的应用场景和好处1.7.1.4 单例设计模式的实现方式很多总结 1.7.2 懒汉式单例设计模式 2. 面向对象三大特征之二继承2.1 继承的快速入门2.1.1 认识继承、特点2.1.1.1 什么是继承2.1.1.2 继承的特点2.1.1.3 继承的执行原理代码实现总结 2.1.2 继承的好处、应用场景2.1.2.1 使用继承有啥好处总结 2.2 继承相关的注意事项2.2.1 权限修饰符2.2.1.1 什么是权限修饰符2.2.1.2 权限修饰符有几种各自的作用是什么代码演示 2.2.2 单继承、Object 类2.2.2.1 单继承2.2.2.2 为何 Java 中的类不支持多继承2.2.2.3 Object 类代码演示总结 2.2.3 方法重写2.2.3.1 认识方法重写2.2.3.2 方法重写的应用场景总结 2.2.4 子类中访问其他成员的特点2.2.5 子类构造器的特点2.2.5.1 认识子类构造器的特点代码演示 2.2.5.1 常见的应用场景代码演示 补充知识this(...) 调用兄弟构造器 2.2.6 注意事项小结 3. 面向对象的三大特征之三多态3.1 认识多态3.1.1 什么是多态3.1.2 多态的具体代码实现3.1.3 多态的前提3.1.4 多态的一个注意事项代码演示 3.2 使用多态的好处3.2.1 使用多态的好处3.2.2 多态下会产生的一个问题怎么解决代码演示总结 3.3 多态下的类型转换问题3.3.1 类型转换3.3.2 强制类型转换的一个注意事项3.3.3 强转前Java 建议代码演示总结 1. static静态
1.1 static 修饰成员变量
1.1.1 static
叫静态可以修饰成员变量、成员方法
成员变量按照有无 static 修饰分为两种
类变量有 static 修饰属于类在计算机里只有一份会被类的全部对象共享实例变量对象的变量无 static 修饰属于每个对象的
public class Student {// 类变量static String name;// 实例变量对象的变量int age;
}
把学生类看成一张学生表可以创建出学生对象 s1 和 s2age 没有 static 修饰所以是对象的变量也就是每个学生对象中都有一个自己的 age。而成员变量 name 有 static 修饰就是类变量就是说它只属于当前这个类自己持有不属于对象也就是说无论我们用这个类创建出了多少个学生对象这些学生对象中都不会持有这个类变量 name
类变量访问方法
类名.类变量推荐
对象.类变量不推荐实例变量访问方法
对象.实例变量1.1.2 成员变量的执行原理 总结
static 是什么
叫静态可以修饰成员变量、成员方法
static 修饰的成员变量叫什么怎么使用有啥特点
类变量静态成员变量
类名.类变量推荐
对象.类变量不推荐属于类与类一起加载一次在内存中只有一份会被类的所有对象共享
无 static 修饰的成员变量叫什么怎么使用有啥特点
实例变量对象变量
对象.实例变量属于对象每个对象中都有一份 1.2 static 修饰成员变量的应用场景
类变量的应用场景
在开发中如果某个数据只需要一份且希望能够被共享访问、修改则该数据可以定义成类变量来记住
案例 系统启动后要求用户类可以记住自己创建了多少个用户对象了 User.java
package Advanced.a_static.d1_staticdemo;public class User {// 类变量public static int number; // public是让它对外完全公开和暴露的public User() {
// User.number;// 注意在同一个类中访问自己类的类变量才可以省略类名不写number;}
}
Test2.java
package Advanced.a_static.d1_staticdemo;public class Test2 {public static void main(String[] args) {// 目标通过案例理解类变量的应用场景User u1 new User();User u2 new User();User u3 new User();User u4 new User();System.out.println(User.number); // 4}
}
总结
成员变量有几种各自在什么情况下定义
类变量数据只需要一份且需要被共享时访问修改实例变量每个对象都要有一份数据各不同如name、score、age
访问自己类中的类变量是否可以省略类名不写
可以的注意在某个类中访问其他类里的类变量必须带类名访问 1.3 static 修饰成员方法
1.3.1 成员方法的分类
类方法有 static 修饰的成员方法属于类
public static void printHelloWorld() {System.out.println(Hello World!);System.out.println(Hello World!);
}类名.类方法推荐
对象名.类方法不推荐实例方法无 static 修饰的成员方法属于对象
public void printPass() {...
}对象.实例方法1.3.2 成员方法的执行原理
 代码演示
Student.java
package Advanced.a_static.d2_static_method;public class Student {double score;// 类方法public static void printHelloWorld() {System.out.println(Hello World!);System.out.println(Hello World!);}// 实例方法对象的方法public void printPass() {System.out.println(成绩 (score 60 ? 及格 : 不及格));}
}
Test.java
package Advanced.a_static.d2_static_method;public class Test {public static void main(String[] args) {// 目标掌握有无static修饰方法的用法// 1. 类方法的用法// 类名.类方法推荐Student.printHelloWorld();// 对象.类方法不推荐Student s new Student();s.printHelloWorld();// 2. 实例方法的用法// 对象.实例方法s.printPass();}
}
总结
static 修饰的成员方法叫什么如何使用
类方法静态方法属于类可以直接用类名访问也可以用对象访问
类名.类方法推荐
对象名.类方法不推荐无 static 修饰的成员方法叫什么如何使用
实例方法对象的方法属于对象只能用对象访问
对象.实例方法补充知识搞懂 mian 方法
public class Test {public static void main(String[] args) {...}
}main 方法是啥方法
类方法 因为有 static
main 方法咋就能直接跑起来
我们用 Java 命令执行这个 Test 程序的时候虚拟机其实会用这个 Test 类直接去点这个 main 方法来触发这个 main 方法的执行为什么可以用类名直接去点这个 main 方法执行呢因为 main 方法也是类方法
参数 String[] args 是什么
当我们来执行这个 main 方法的时候实际上我们可以送一些数据给这个参数接收的这个参数它是一个 String 类型的数组它可以接一些数据然后让你这个 main 方法里面的程序来使用这些数据
怎么在执行 main 方法的时候把数据传给这个参数String[] args呢
在调用 java 命令执行时直接跟在文件名后面 1.4 static 修饰成员方法的应用场景
1.4.1 类方法的常见应用场景
类方法最常见的应用场景是做工具类
1.4.2 工具类是什么
工具类中的方法都是一些类方法每个方法都是用来完成一个功能的工具类是给开发人员共同使用的
1.4.3 使用类方法来设计工具类有啥好处
提高了代码复用调用方便提高了开发效率
public class XxxxUtil {public static void xxx() {...}public static boolean xxxx(String email) {...}public static String xxxxx(int n) {...}...
}案例 需求 某系统的登录界面需要开发并展示四位随机的验证码系统的注册界面需要开发并展示六位的随机验证码 这两套程序的代码几乎一模一样存在大量重复代码这时我们就可以使用类方法设计一个工具类让这两个程序来调用这样就优化好这个结构了
代码实现
MyUtil.java
package Advanced.a_static.d3_util;import java.util.Random;public class MyUtil {private MyUtil() {}public static String createCode(int n) {// 1. 定义2个变量是一个是记住最终产生的随机验证码一个是记住可能用到的全部字符String code ;String data abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ;Random r new Random();// 2. 开始定义一个循环产生每位随机数字符for (int i 0; i 4; i) {// 3. 随机一个字符范围内的索引int index r.nextInt(data.length());// 4. 根据索引去全部字符中提取该字符code data.charAt(index); // code code 字符}return code;}
} 为什么工具类中的方法要用类方法而不是实例方法 实例方法需要创建对象来调用此时对象只是为了调用方法对象占内存这样会浪费内存
多学一招
工具类没有创建对象的需求建议将工具类的构造器进行私有
总结
类方法有啥应用场景
可以用来设计工具类
工具类是什么有什么好处
工具类中的方法都是类方法每个类方法都是用来完成一个功能的提高了代码的复用性调用方便提高了开发效率
为什么工具类要用类方法而不是实例方法
实例方法需要创建对象来调用会浪费内存
工具类定义时有什么要求
工具类不需要创建对象建议将工具类的构造器私有化 1.5 static 的注意事项
类方法中可以直接访问类的成员不可以直接访问实例成员实例方法既可以直接访问类成员也可以直接访问实例成员实例方法中可以出现 this 关键字类方法中不可以出现 this 关键字的
代码演示
package Advanced.a_static.d4_static_attention;public class Student {static String schoolName; // 类变量double score; // 实例变量// 1. 类方法中可以直接访问类的成员不可以直接访问实例成员public static void printHelloWorld() {// 注意同一个类中访问类成员可以省略类名不写schoolName Feng;Student.printHelloWorld2();// System.out.println(score); // 会报错
// printPass(); // 会报错// System.out.println(this); // 会报错}// 类方法public static void printHelloWorld2() {}// 2. 实例方法中既可以直接访问类成员也可以直接访问实例成员// 实例方法// 3. 实例方法中可以出现this关键字类方法中不可以出现this关键字public void printPass() {schoolName Feng2;printHelloWorld2();System.out.println(score);printPass2();System.out.println(this); // 哪个对象调用它的实例方法 this就会指向哪个对象}// 实例方法public void printPass2() {}
} 1.6 static 的应用知识代码块
1.6.1 代码块概述
代码块是类的的5大成分之一成员变量、构造器、方法、代码块、内部类
代码块分为两种 静态代码块 格式static {}特点类加载时自动执行由于类只会加载一次所以静态代码块也只会执行一次作用完成类的初识化例如对类变量的初始化赋值 实例代码块 格式{}特点每次创建对象时执行实例代码块并在构造器前执行作用和构造器一样都是用来完成对象的初始化的例如对实例对象变量进行初始化赋值
代码演示
Student.java
package Advanced.a_static.d5_block;public class Student {static int number 80;static String schoolName;// 静态代码块static {System.out.println(静态代码块执行了);schoolName Feng;}// 实例代码块{System.out.println(实例代码块执行了~~~);System.out.println(有人创建了对象 this);}public Student() {System.out.println(无参数构造器执行了~~~);}public Student(String name) {System.out.println(有参数构造器执行了~~~);}
}
Test.java
package Advanced.a_static.d5_block;public class Test {public static void main(String[] args) {// 目标认识两种代码块了解他们的特点和基本作用System.out.println(Student.number); // 静态代码块执行了 80System.out.println(Student.number); // 80System.out.println(Student.number); // 80System.out.println(Student.schoolName); // FengSystem.out.println(-----------------------);Student s1 new Student(); // 实例代码块执行了~~~ 有人创建了对象Advanced.a_static.d5_block.Studentb4c966a 无参数构造器执行了~~~Student s2 new Student(张三); // 实例代码块执行了~~~ 有人创建了对象Advanced.a_static.d5_block.Student1d81eb93 有参数构造器执行了~~~}
} 1.7 static 的应用知识单例设计模块
1.7.1 什么是设计模式Design pattern
一个问题通常有 n 种解法其中肯定有一种解法是最优的这个最优的解法被人总结出来了称之为设计模式设计模式有20多种对应20多种软件开发中会遇到的问题
1.7.1.2 单例设计模式饿汉式单例
确保一个类只有一个对象
写法
把类的构造器私有定义一个类变量记住类的一个对象定义一个类方法返回对象
代码实现
A.java
package Advanced.a_static.d6_singleInstance;public class A {// 2.定义一个类变量记住类的对象private static A a new A();// 1. 必须私有类的构造器// 使得外面不能创建对象private A() {}// 3. 定义一个类方法返回类的对象public static A getObject() {return a;}
}
Test1.java
package Advanced.a_static.d6_singleInstance;public class Test1 {public static void main(String[] args) {// 目标掌握单例设计模式的写法A a1 A.getObject();A a2 A.getObject();System.out.println(a1); // Advanced.a_static.d6_singleInstance.Ab4c966aSystem.out.println(a2); // Advanced.a_static.d6_singleInstance.Ab4c966a}
}
1.7.1.3 单例模式的应用场景和好处
Runtime 类 程序的运行环境Java 程序执行的时候只有一套运行环境因此 Runtime 它也只需要一个对象就可以代表你那个唯一的运行环境 任务管理器 无论启动多少次任务管理器其窗口对象始终只有一个
1.7.1.4 单例设计模式的实现方式很多 总结
什么是设计模式设计模式主要学什么单例模式解决了上面问题
设计模式就是具体问题的最优解决方案解决了什么问题怎么写确保一个类只有一个对象
单例怎么写饿汉式单例的特点是什么
把类的构造器私有定义一个类变量存储类的一个对象提供一个类方法返回对象在获取类对象时对象已经创建好了
单例有啥应用场景有啥好处
任务管理器对象、获取运行时对象在这些业务场景下使用单例模式可以避免浪费内存 1.7.2 懒汉式单例设计模式
拿对象时才开始创建对象
写法
把类的构造器私有定义一个类变量用于存储对象提供一个类方法保证返回的是同一个对象
代码实现
B.java
package Advanced.a_static.d6_singleInstance;public class B {// 2. 定义一个类变量用于存储这个类的一个对象private static B b;// 1. 把类的构造器私有private B() {}// 3. 定义一个类方法这个方法要保证第一次调用时才创建一个对象后面调用时都会用这同一个对象返回public static B getInstance() {if (b null) {System.out.println(第一次创建对象~~~);b new B();}return b;}
}
Test2.java
package Advanced.a_static.d6_singleInstance;/*** 目标掌握懒汉式单例的写法*/public class Test2 {public static void main(String[] args) {B b1 B.getInstance(); // 第一次拿对象B b2 B.getInstance();System.out.println(b1 b2); // true}
} 2. 面向对象三大特征之二继承
2.1 继承的快速入门
2.1.1 认识继承、特点
2.1.1.1 什么是继承
Java 中提供了一个关键字 extends用这个关键字可以让一个类和另一个类建立起父子关系
public class B extends A {}A 类称之为父类基类或超类B 类称之为子类派生类 2.1.1.2 继承的特点
子类能继承父类的非私有成员成员变量、成员方法
继承后对象的创建
子类的对象是由子类、父类共同完成的
2.1.1.3 继承的执行原理 子类对象实际上是由子父类这两张设计图共同创建出来的
代码实现
A.java
package Advanced.b_extends.d7_extends;// 父类
public class A {// 公开成员public int i;public void print1() {System.out.println(print1);}// 私有成员private int j;private void print2() {System.out.println(print2);}
}
B.java
package Advanced.b_extends.d7_extends;// 子类
public class B extends A {// 子类是可以继承父类的非私有成员public void print3() {System.out.println(i);print1();// System.out.println(j); // 报错
// print2(); // 报错}
}
Test.java
package Advanced.b_extends.d7_extends;public class Test {public static void main(String[] args) {// 目标认识继承、掌握继承的特点B b new B();System.out.println(b.i); // 0
// System.out.println(b.j); // 报错b.print1();
// b.print2(); // 报错b.print3();}
}
总结
什么是继承继承后有啥特点
继承就是用 extends 关键字让一个类和另一个类建立起一种父子关系子类可以继承父类非私有的成员
带继承关系的类Java 会怎么创建它的对象对象创建出来后可以直接访问哪些成员
带继承关系的类Java 会用类和其父类这多张设计图来一起创建类的对象对象能直接访问什么成员是由子父类这多张设计图共同决定的这多张设计图对外暴露了什么成员对象就可以访问什么成员 2.1.2 继承的好处、应用场景
2.1.2.1 使用继承有啥好处
减少重复代码的编写 需求 Feng 的员工管理系统种 需要处理讲师、咨询师的数据 讲师的数据有姓名、具备的技能 咨询师的数据有姓名、解答问题的总人数 代码实现
People.java
package Advanced.b_extends.d8_extends_application;public class People {private String name;public String getName() {return name;}public void setName(String name) {this.name name;}
}
Teacher.java
package Advanced.b_extends.d8_extends_application;public class Teacher extends People {private String skill;public String getSkill() {return skill;}public void setSkill(String skill) {this.skill skill;}public void printInfo() {System.out.println(getName() 具备的技能 skill);}
}
Test.java
package Advanced.b_extends.d8_extends_application;public class Test {public static void main(String[] args) {// 目标搞清楚继承的好处Teacher t new Teacher();t.setName(张三);t.setSkill(Java、Spring);System.out.println(t.getName()); // 张三System.out.println(t.getSkill()); // Java、Springt.printInfo(); // 张三具备的技能Java、Spring}
}
总结
使用继承有啥好处
减少了重复代码的编写提高了代码的复用性 2.2 继承相关的注意事项
2.2.1 权限修饰符
2.2.1.1 什么是权限修饰符
就是用来限制类中的成员成员变量、成员方法、构造器、代码块…能够被访问的范围
2.2.1.2 权限修饰符有几种各自的作用是什么
修饰符在本类中同一个包下的其他类里任意包下的子类里任意包下的任意类里private√缺省√√protected√√√public√√√√
private 缺省 protected public
代码演示
d9_modifer.Fu.java
package Advanced.b_extends.d9_modifer;public class Fu {// 1. 私有只能在本类中访问private void privateMethod(){System.out.println(private);}// 2. 缺省本类同一个包下的类void method(){System.out.println(缺省);}// 3. protected本类同一个包下的类任意包下的子类protected void protectedMethod(){System.out.println(protected);}// 4. public本类同一个包下的类任意包下的子类任意包下的任意类public void publicMethod(){System.out.println(public);}public void test(){privateMethod();method();privateMethod();publicMethod();}
}
d9_modifer.Demo.java
package Advanced.b_extends.d9_modifer;public class Demo {public static void main(String[] args) {// 目标掌握不同权限修饰符的作用Fu f new Fu();
// f.privateMethod(); // 报错f.method();f.protectedMethod();f.publicMethod();}
}
d10_modifer.Zi.java
package Advanced.b_extends.d10_modifer;import Advanced.b_extends.d9_modifer.Fu;public class Zi extends Fu {public void test() {
// privateMethod(); // 报错
// method(); // 报错protectedMethod();publicMethod();}
}
d10_modifer.Demo2.java
package Advanced.b_extends.d10_modifer;import Advanced.b_extends.d9_modifer.Fu;public class Demo2 {public static void main(String[] args) {Fu f new Fu();
// f.privateMethod(); // 报错
// f.method(); // 报错
// f.protectedMethod(); // 报错f.publicMethod();Zi zi new Zi();
// zi.protectedMethod(); // 报错}
} 2.2.2 单继承、Object 类
2.2.2.1 单继承
Java 是单继承的Java 中的类不支持多继承但是支持多层继承
单继承指的是一个类只能继承一个直接父类
2.2.2.2 为何 Java 中的类不支持多继承
反证法
假设 Java 中的类支持多继承现在有两个类一个 A 中有一个 method 方法里面打印 “aaa”一个 B 中有一个 method 方法里面打印 “bbb”再定义一个 C 类同时继承 A 和 B那么 C 调用 method 方法时就不知道调用谁的方法了
2.2.2.3 Object 类
Object 类是 Java 所有类的祖宗类。我们写的任意一个类其实都是 Object 的子类或者子孙类
代码演示
package Advanced.b_extends.d11_extends_feature;public class Test {public static void main(String[] args) {// 目标掌握继承的两个注意事项// 1. Java是单继承的一个类只能继承一个直接父类Java中的类不支持多继承但支持多层继承// 2. Object类是Java中所有类的祖宗A a new A();B b new B();}
}class A {
} // extends Object{}class B extends A {
}//class C extends B, A{} // 报错class D extends B {
}
总结
继承相关的两个注意事项 Java 是单继承的一个类只能继承一个直接父类Java 中的类不支持多继承但是支持多层继承 Object 类是 Java 中所有类的祖宗 2.2.3 方法重写
2.2.3.1 认识方法重写
什么是方法重写
当子类觉得父类中的某个方法不好用或者无法满足自己的需求时子类可以重写一个方法名称、参数列表一样的方法去覆盖父类的这个方法这就是方法重写注意重写后方法的访问Java 会遵循就近原则
方法重写的其他注意事项
重写小技巧使用 Override 注解他可以指定 Java 编译器检查我们方法重写的格式是否正确代码可读性也会更好子类重写父类方法时访问权限必须大于或者等于父类该方法的权限public protected 缺省重写的方法返回值类型必须与被重写方法的返回值类型一样或者范围更小私有方法、静态方法不能被重写如果重写会报错的
代码演示
A.java
package Advanced.b_extends.d12_extends_override;public class A {public void print1() {System.out.println(111);}public void print2(int a, int b) {System.out.println(111111);}
}
B.java
package Advanced.b_extends.d12_extends_override;public class B extends A {// 方法重写Override // 安全可读性好public void print1() {System.out.println(666);}// 方法重写Overridepublic void print2(int a, int b) {System.out.println(666666);}
}
Test.java
package Advanced.b_extends.d12_extends_override;public class Test {public static void main(String[] args) {// 目标认识方法重写掌握方法重写的常见应用场景B b new B();b.print1(); // 666b.print2(2, 3); // 666666}
}
2.2.3.2 方法重写的应用场景
子类重写 Object 类的 toString() 方法以便返回对象的内容
代码演示
Student.java
package Advanced.b_extends.d12_extends_override;public class Student {private String name;private int age;public Student() {}public Student(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;}Overridepublic String toString() {return Student{ name name \ , age age };}
}
Test.java
package Advanced.b_extends.d12_extends_override;import java.util.ArrayList;public class Test {public static void main(String[] args) {// 目标认识方法重写掌握方法重写的常见应用场景B b new B();b.print1(); // 666b.print2(2, 3); // 666666System.out.println(----------------------------);Student s new Student(张三, 19);System.out.println(s.toString()); // Advanced.b_extends.d12_extends_override.Student4e50df2e Student{name张三,age19}System.out.println(s); // Advanced.b_extends.d12_extends_override.Student4e50df2e Student{name张三,age19}ArrayList list new ArrayList();list.add(java);System.out.println(list); // [java] 说明ArrayList类中把Object类里面的toString方法进行了重写}
}
总结
方法重写是什么
子类写了一个方法名称、形参列表与父类某个方法一样的方法去覆盖父类的该方法
重写方法有哪些注意事项
建议加上Override 注解可以校验重写是否正确同时可读性好子类重写父类方法时访问权限必须大于或者等于父类被重写的方法的权限重写的方法返回值类型必须与被重写方法的返回值类型一样或者范围更小私有方法、静态方法不能被重写
方法重写有啥应用场景
当子类觉得父类的方法不好用或者不满足自己的需求时就可以用方法重写 2.2.4 子类中访问其他成员的特点
在子类方法中访问其他成员成员变量、成员方法是依照就近原则的
先子类局部范围找然后子类成员范围找然后父类成员范围找如果父类范围还没有找到则报错
如果父类中出现了重名的成员会优先使用子类的如果此时一定要在子类中使用父类的怎么办
可以通过 super 关键字指定访问父类的成员super.父类成员变量/父类成员方法
代码演示
F.java
package Advanced.b_extends.d13_extends_visit;public class F {String name 父类名字;public void print1() {System.out.println(父类的print1方法执行);}
}
Z.java
package Advanced.b_extends.d13_extends_visit;public class Z extends F {String name 子类名称;public void showName() {String name 局部名称;System.out.println(name);System.out.println(this.name);System.out.println(super.name);}Overridepublic void print1() {System.out.println(子类的print1方法执行了);}public void showMethod() {print1(); // 子类的super.print1(); // 父类的}
}
Test.java
package Advanced.b_extends.d13_extends_visit;public class Test {public static void main(String[] args) {// 目标掌握子类中访问其他成员的特点就近原则Z z new Z();z.showName(); // 局部名称 子类名称 父类名字z.showMethod(); // 子类的print1方法执行了 父类的print1方法执行}
} 2.2.5 子类构造器的特点
2.2.5.1 认识子类构造器的特点
子类构造器的特点
子类的全部构造器都会先调用父类的构造器再执行自己
子类构造器是如何实现调用父类构造器的
默认情况下子类全部构造器的第一行代码都是 super(); 写不写都有它会调用父类的无参数构造器如果父类没有无参数构造器则我们必须在子类构造器的第一行手写 super(...); 指定去调用父类的有参数构造器
代码演示
package Advanced.b_extends.d14_extends_constructor;class F {
// public F() {
// System.out.println(父类F的无参数构造器执行了);
// }public F(String name, int age) {}
}class Z extends F {public Z() {
// super(); // 默认存在的super(张三,17);System.out.println(子类Z的无参数构造器执行了);}public Z(String name) {
// super(); // 默认存在的super(张三,17);System.out.println(子类Z的有参数构造器执行了);}
}public class Test {public static void main(String[] args) {// 目标先认识子类构造器的特点再掌握这个特点的常见应用场景Z z new Z(); // 父类F的无参数构造器执行了 子类Z的无参数构造器执行了Z z2 new Z(张三); // 父类F的无参数构造器执行了 子类Z的有参数构造器执行了}
}
2.2.5.1 常见的应用场景
搞清楚子类构造器为什么要调用父类的构造器有啥应用场景
在继承情况下由于处理对象数据的构造器拆到了多个类里面去了所以对象要通过调用这多个构造器才能把对象的数据处理完整
运行过程 子类构造器可以通过父类构造器把对象中包含父类这部分的数据先初始化赋值再回来把对象里包含子类这部分的数据也进行初始化赋值
代码演示
package Advanced.b_extends.d14_extends_constructor;public class Test2 {public static void main(String[] args) {// 目标搞清楚子类构造器为什么要调用父类的构造器有啥应用场景Teacher t new Teacher(李四, 36, Java);System.out.println(t.getName()); // 李四System.out.println(t.getAge()); // 36System.out.println(t.getSkill()); // Java}
}class Teacher extends People {private String skill;public Teacher(String name, int age, String skill) {super(name, age);this.skill skill;}public String getSkill() {return skill;}public void setSkill(String skill) {this.skill skill;}
}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;}
}
补充知识this(…) 调用兄弟构造器
任意类的构造器中是可以通过 this(...) 去调用该类的其他构造器的
this(…) 和 super(…) 使用时的注意事项
this(…)、super(…) 都只能放在构造器的第一行因此有了 this(…) 就不能写 super(…) 了反之亦然
代码演示
package Advanced.b_extends.d14_extends_constructor;public class Test3 {public static void main(String[] args) {// 目标掌握在类的构造器中通过this(...)调用兄弟构造器的作用Student s1 new Student(李四, 26, 家里蹲大学);// 需求如果学生没有填写学校那么学校默认就是FengStudent s2 new Student(张三, 28);System.out.println(s2.getName()); // 张三System.out.println(s2.getAge()); // 28System.out.println(s2.getSchoolName()); // Feng}
}class Student {private String name;private int age;private String schoolName;public Student() {}public Student(String name, int age) {this(name, age, Feng);}public Student(String name, int age, String schoolName) {this.name name;this.age age;this.schoolName schoolName;}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 String getSchoolName() {return schoolName;}public void setSchoolName(String schoolName) {this.schoolName schoolName;}
} 2.2.6 注意事项小结
子类构造器有啥特点
子类中的全部构造器都必须先调用父类的构造器再执行自己
super(…) 调用父类有参数构造器的常见场景是什么
为对象中包含父类这部分的成员变量进行赋值
this(…) 的作用是什么
在构造器中调用本类的其他构造器
this(…) 和 super(…) 的使用需要注意什么
都必须放在构造器的第一行 3. 面向对象的三大特征之三多态
3.1 认识多态
3.1.1 什么是多态
多态是在继承/实现情况下的一种现象表现为对象多态、行为多态
3.1.2 多态的具体代码实现
People p1 new Student();
p1.run();People p2 new Teacher();
p2.run();3.1.3 多态的前提
有继承/实现关系存在父类引用子类对象存在方法重写
3.1.4 多态的一个注意事项
多态是对象、行为的多态Java 中的属性成员变量不谈多态
代码演示
People.java
package Advanced.c_polymorphism.d1_polymorphism;// 父类
public class People {public String name 父类People的名称;public void run() {System.out.println(人可以跑~~~);}
}
Student.java
package Advanced.c_polymorphism.d1_polymorphism;public class Student extends People {public String name 子类Student的名称;Overridepublic void run() {System.out.println(学生跑得贼快~~~);}
}
Teacher.java
package Advanced.c_polymorphism.d1_polymorphism;public class Teacher extends People {public String name 子类Teacher的名称;Overridepublic void run() {System.out.println(老师跑的气喘吁吁~~~);}
}
Test.java
package Advanced.c_polymorphism.d1_polymorphism;public class Test {public static void main(String[] args) {// 目标认识多态对象多态、行为多态// 1. 对象多态People p1 new Teacher();// 行为多态识别技巧编译看左边运行看右边p1.run(); // 老师跑的气喘吁吁~~~// 注意对于变量编译看左边运行看左边System.out.println(p1.name); // 父类People的名称People p2 new Student();// 行为多态识别技巧编译看左边运行看右边p2.run(); // 学生跑得贼快~~~System.out.println(p2.name); // 父类People的名称}
} 3.2 使用多态的好处
3.2.1 使用多态的好处 在多态形势下右边对象是解耦合的更便于扩展和维护 解耦合比如说我们在开发系统时希望把这个系统中的每个模块拆分成一个一个的服务可以随时的对接这样更容易扩展和维护这就是解耦合 定义方法时使用父类类型的形参可以接收一切子类对象扩展性更强、更便利
3.2.2 多态下会产生的一个问题怎么解决
多态下不能使用子类的独有功能
代码演示
People.java
package Advanced.c_polymorphism.d2_polymorphism;// 父类
public class People {public String name 父类People的名称;public void run() {System.out.println(人可以跑~~~);}
}
Student.java
package Advanced.c_polymorphism.d2_polymorphism;public class Student extends People {public String name 子类Student的名称;Overridepublic void run() {System.out.println(学生跑得贼快~~~);}public void test() {System.out.println(学生需要考试~~~);}
}
Teacher.java
package Advanced.c_polymorphism.d2_polymorphism;public class Teacher extends People {public String name 子类Teacher的名称;Overridepublic void run() {System.out.println(老师跑的气喘吁吁~~~);}public void test() {System.out.println(老师需要教知识~~~);}
}
Test.java
package Advanced.c_polymorphism.d2_polymorphism;public class Test {public static void main(String[] args) {// 目标理解多态的好处// 好处1可以实现解耦合右边对象可以随时切换后续业务随之改变People p1 new Student();p1.run();
// p1.test(); // 多态下存在的问题无法直接调用子类的独有功能Student s new Student();go(s);Teacher t new Teacher();go(s);}// 好处2可以使用父类类型的变量作为形参可以接收一切子类对象public static void go(People p) {}
}
总结
使用多态有什么好处存在什么问题
可以解耦合扩展性更强使用父类类型的变量作为方法的形参时可以接收一切子类对象多态下不能直接调用子类的独有方法 3.3 多态下的类型转换问题
3.3.1 类型转换 自动类型转换父类 变量名 new 子类(); egPeople p new Teacher(); 强制类型转换子类 变量名 (子类) 父类变量 egTeacher t (Teacher) p;
3.3.2 强制类型转换的一个注意事项
存在继承/实现关系就可以在编译阶段进行强制类型转换编译阶段不会报错运行时如果发现对象的真实类型与强转后的类型不同就会报类型转换异常ClassCastException的错误出来
People p new Teahcer();Student s (Student) p; // java.lang.ClassCastException3.3.3 强转前Java 建议
使用 instanceof 关键字判断当前对象的真实类型再进行强转
p instanceof Student代码演示
People.java
package Advanced.c_polymorphism.d2_polymorphism;// 父类
public class People {public String name 父类People的名称;public void run() {System.out.println(人可以跑~~~);}
}
Student.java
package Advanced.c_polymorphism.d2_polymorphism;public class Student extends People {public String name 子类Student的名称;Overridepublic void run() {System.out.println(学生跑得贼快~~~);}public void test() {System.out.println(学生需要考试~~~);}
}
Teacher.java
package Advanced.c_polymorphism.d2_polymorphism;public class Teacher extends People {public String name 子类Teacher的名称;Overridepublic void run() {System.out.println(老师跑的气喘吁吁~~~);}public void teach() {System.out.println(老师需要教知识~~~);}
}
Test.java
package Advanced.c_polymorphism.d2_polymorphism;public class Test {public static void main(String[] args) {// 目标理解多态的好处// 好处1可以实现解耦合右边对象可以随时切换后续业务随之改变People p1 new Student();p1.run();
// p1.test(); // 多态下存在的问题无法直接调用子类的独有功能// 强制类型转换Student s1 (Student) p1;s1.test(); // 学生需要考试~~~// 强制类型转换可能存在的问题编译阶段有继续或者实现关系就可以强制转换但是运行时可能出现类型转换异常
// Teacher t1 (Teacher) p1; // 运行时出现了ClassCastExceptionif (p1 instanceof Student) {Student s2 (Student) p1;s2.test(); // 学生需要考试~~~} else {Teacher t2 (Teacher) p1;t2.teach();}System.out.println(------------------------------);// 好处2可以使用父类类型的变量作为形参可以接收一切子类对象Student s new Student();go(s); // 学生跑得贼快~~~ 学生需要考试~~~Teacher t new Teacher();go(t); // 老师跑的气喘吁吁~~~ 老师需要教知识~~~}// 好处2可以使用父类类型的变量作为形参可以接收一切子类对象public static void go(People p) {p.run();if (p instanceof Student) {Student s2 (Student) p;s2.test();} else if (p instanceof Teacher) {Teacher t2 (Teacher) p;t2.teach();}}
}
总结
类型转换有几种形式能解决什么问题
自动类型转换、强制类型转换可以把对象转换成其真正的类型从而解决了多态下不能调用子类独有方法的问题
强制类型转换需要注意什么
存在继承/实现时就可以进行强制类型转换编译阶段不会报错但是运行时如果发现对象的真是类型与强转后的类型不同会报错ClassCastException
强制类型转换前Java 建议我们做什么事情
使用 instanceof 判断当前对象的真是类型对象 instanceof 类型
