知识点：
综合案例
一、综合案例
1.1 练习 1：设计汽车示例
创建 Java 工程: DAY05
创建包: cn.tedu. oopextends
创建类: Test1_ExtendsDesignCar.java
package cn.tedu.oopextends;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午4:41:34
*/
/**本类用于测试继承设计汽车综合案例*/
//分析:
//提取共性:生成汽车父类
//属性:颜色 型号
//方法:启动行为 停止行为
//具体事物:宝马汽车 奥迪汽车—继承汽车父类,享有父类的共有属性和方法
public class Test1_ExtendsDesignCar {
public static void main(String[] args) {
//3.1创建父类对象进行测试
Car c = new Car();
c.run();
c.stop();
//3.2创建子类对象进行测试
BMW b = new BMW();
b.run();
b.stop();
//3.3创建子类对象进行测试
Audi a = new Audi();
a.run();
a.stop();
}
}
//0.抽取共性来创建汽车父类
class Car{
//定义属性--特征
String bround;//汽车品牌
String color;//汽车颜色
//定义方法--功能
public void run() {
System.out.println("汽车启动");
}
public void stop() {
System.out.println("汽车停止");
}
}
//1.创建宝马汽车类,继承汽车类,继承后,子类具有父类的功能
class BMW extends Car{
//4.如果想要修改父类原有的功能:--方法的重写
//4.1重写后,父类的原有功能没有备修改,改的是子类自己的功能
public void run() {
//4.2 super应用在子类中,表示父类对象的一个引用Car super = new Car();
super.run();
System.out.println("BMW汽车启动....起步快!");
}
}
//2.创建奥迪汽车类,继承汽车类,继承后,子类具有父类的功能
class Audi extends Car{
public void stop() {
System.out.println("Audi汽车停止...刹车灵!");
}
}二、static
2.1 概念
是 java 中的一个关键字
用于修饰成员（成员变量和成员方法）
2.2 特点
1) 随着类的加载而加载，静态资源也叫做类资源
2) 只加载一次，就会一直存在，直到类消失就一起消失了
3) 优先于对象加载
4) 被所有对象所共享
5) 可以直接被类名调用
2.3 练习 2：static 入门案例
创建 Java 工程: DAY05
创建包: cn.tedu. oopstatic
创建类: Test2_ StaticDemo.java
package cn.mbh.oopstatic;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午5:00:48
*/
/**本类用于测试static静态的入门案例*/
public class Test2_StaticDemo {
public static void main(String[] args) {
//3.创建对象进行测试
/**3.静态资源可以通过类名直接调用*/
/**4.静态资源是优先于对象加载的,比对象先加载进入内存,没对象也可以直接被类名调用*/
Student s = new Student();
s.study();
//4.通过类名直接调用静态资源进行测试
System.out.println(Student.name);
Student.study();
//5.测试多个队形访问静态资源
/**5.静态资源可以被多个对象共享*/
Student s2 = new Student();
System.out.println(s2.name);
System.out.println(Student.name);
}
}
//1.创建Student类
class Student{
//2.定义属性与方法
/**1.使用static关键字可以将普通资源修饰成静态资源*/
/**2.static可以用来修饰成员变量/方法,一般写在权限修饰符之后*/
static String name = "韭菜妃子";
static public void study() {
System.out.println("别闹,我学java呢~");
}
}2.4 练习 3：static 静态调用关系
创建 Java 工程: DAY05
创建包: cn.tedu. oopstatic
创建类: Test3_ Static1.java
package cn.mbh.oopstatic;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午5:14:40
*/
/**本类用于测试静态的调用关系*/
//总结:
//1.静态只能调用静态资源
//2.非静态既可以调用静态,也可以调用非静态
public class Test3_Static1 {
public static void main(String[] args) {
}
}
//1.创建Teacher类
class Teacher{
//1.1定义普通资源
String name;
public void teach() {
/**1.普通资源能否调用静态资源?--可以!!!*/
eat();//普通资源可以调用静态方法
System.out.println(age);//普通资源可以调用静态属性
System.out.println("teach()....");
}
//1.2定义静态资源
static int age;//定义静态属性
static public void eat() {//定义静态方法
/**2.静态资源能否调用普通资源?--不可以!!!*/
//System.out.println(name);
//teach();静态方法不可以调用普通方法
System.out.println("eat()....");
/**3.静态资源能否调用静态资源?--可以!!!*/
System.out.println(age);//静态资源可以调用静态属性
study();//静态资源可以调用静态方法
}
public static void study() {
System.out.println("study()....");
}
}三、静态代码块、构造代码块、局部代码块
3.1 静态代码块格式
static {}
静态资源随着类的加载而加载，并且只被加载一次，一般用于项目的初始化
3.2 三种代码块的比较
1) 静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化
2) 构造代码块：在创建对象时会自动调用，每次创建对象都会被调用,提取构造共性
3) 局部代码块：方法里的代码块,限制局部变量的范围
3.3 练习 4：几种代码块的关系
创建 Java 工程: DAY05
创建包: cn.tedu. block
创建类: Test4_Block2.java
package cn.mbh.block;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午5:23:38
*/
/**本类用于测试代码块之间的关系*/
//1.代码块之间的执行顺序:静态代码块 --> 构造代码块 --> 构造方法 --> 局部代码块
//2.为什么是这样子的顺序呢?
//3.原因:
//3.1)静态代码块优先于对象加载,是随着类的加载就会第一时间加载进入内存,并且一直存在
//3.1.1)专门用来完成一些需要第一时间加载并且只记在一次的资源
//3.2)构造代码块是在创建对象时才会触发,专门用来提取构造方法的共性
//3.3)局部代码块是在方法调用时才会触发,专门用来控制变量的作用范围
public class Test4_Block2 {
public static void main(String[] args) {
//7.创建对象进行测试
/**1.在创建对象前,会自动执行静态代码块,而且此代码块只加载一次*/
/**2.在创建对象时,会自动调用构造代码块和构造方法*/
Person p = new Person();
/**3.当调用方法时,如果方法中有局部代码块,才会触发局部代码块*/
p.study();
System.out.println("-----------------我是一个无情的分割线-----------------------");
//8.再创建一次对象进行测试
Person p2 = new Person();//再去创建对象,静态代码块也不会再次加载了
p2.study();
}
}
//1.创建Person类
class Person{
//2.创建静态代码块
/**位置:类里方法外 + 触发节点:随着类的加载而加载,只加载一次 */
static {
System.out.println("我是静态代码块~");
}
//3.创建构造代码块
/**位置:类里方法外 + 触发节点:创建对象时 */
{
System.out.println("我是构造代码块");
}
//4.创建构造方法
public Person() {
System.out.println("我是无参构造方法~");
}
//5.创建普通方法
public void study() {
System.out.println("我是普通方法~");
//6.创建局部代码块
/**位置:方法里 + 触发节点:调用此方法时 */
{
System.out.println("我是局部代码块");
}
}
}四、final
4.1 概念
1) 是 java 提供的一个关键字
2) final 是最终的意思
3) final 可以修饰类，方法，成员变量
4.2 特点
1) 被 final 修饰的类，不能被继承
2) 被 final 修饰的方法，不能被重写
3) 被 final 修饰的变量是个常量，不能被改变
4) 常量的定义形式：final 数据类型 常量名 = 值
4.3 练习 5：final 入门案例
创建 Java 工程: DAY05
创建包: cn.tedu. oopfinal
创建类: Test5_FinalDemo.java
package cn.mbh.oopfinal;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午5:33:23
*/
/**本类用于测试final的入门案例*/
public class Test5_FinalDemo {
public static void main(String[] args) {
//5.创建子类对象进行测试
Son4 s = new Son4();
System.out.println(s.name);
//s.name="打工人";//The final field Father4.name cannot be assigned
s.eat();
}
}
//1.创建父类
/**1.final表示最终,可以用来修饰类,那么被final修饰的类无法被继承,也就是没有子类--最终类*/
class Father4{
//3.创建成员变量
/**2.final可以修饰成员变量,被final修饰的变量值不可以被修改--常量*/
final String name = "干饭人";
//4.创建成员方法
/**3.final可以修饰成员方法,但是被final修饰的方法是最终实现,子类无法重写*/
final public void eat() {
System.out.println("Father4...干它三碗大米饭~");
}
}
//2.创建子类
class Son4 extends Father4{
//子类重写父类的eat()
// public void eat() {//Cannot override the final method from Father4
// System.out.println("Son4...下雪了去吃火锅吧~");
// }
}五、多态
5.1 概念
多态指同一个实体同时具有多种形式
它是面向对象程序设计（OOP ）的一个重要特征。
主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
好处是：可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出 通用的编程，统一调用标准。
水果有两种形态：水果和苹果,不关心买回来的是苹果还是西瓜,只要是水果就行
class Animal{//1. 定义父类 Animal
....
}
class Cat extends Animal{//2. 定义子类 Cat 继承 Animal
....
}
main(){
//3.创建子类对象
Cat c = new Cat();//小猫是小猫
Animal a = new Cat();//小猫是小动物
}
5.2 特点
1) 多态的前提 1：是继承
2) 多态的前提 2：要有方法的重写
3) 父类引用指向子类对象,如：Animal a = new Cat();
4) 多态中，编译看左边，运行看右边
5.3 练习 6：多态入门案例
创建 Java 工程: DAY05
创建包: cn.tedu. oop
创建类: Test6_MoreTypeDemo.java
package cn.mbh.opp;
/**
*@author MBH:
*@version 创建时间：2022年7月10日 下午5:43:12
*/
/**本类用于测试多态的入门案例*/
public class Test6_MoreTypeDemo {
public static void main(String[] args) {
//5.创建父类对象进行测试
Animal a = new Animal();
a.eat();//小动物Animal吃啥都行~~~
//6.创建子类对象进行测试
Cat c = new Cat();
c.eat();//小猫Cat爱吃小鱼干~~~
c.jump();
//!!!7.创建多态对象进行测试
/**口诀1 : 父类引用 指向 子类对象*/
/**口诀2 : 编译(保存)看左边,运行(测试)看右边*/
Animal a2 = new Cat();
//eat()是使用的父类的声明,但是使用的是子类的实现方式
a2.eat();//小猫Cat爱吃小鱼干~~~
/**多态的出现:是为了统一调用的标准,向父类看齐,父类提供的功能才能用,子类特有的功能用不了*/
//a2.jump();
}
}
//1.创建父类
class Animal{
//3.定义父类中的成员方法
public void eat() {
System.out.println("小动物Animal吃啥都行~~~");
}
}
//2.创建子类
class Cat extends Animal{
//4.重写父类中的方法--对父类的代码做修改
//重写的规则:方法签名保持一致 + 子类权限修饰符 >= 父类的权限修饰符
public void eat() {
System.out.println("小猫Cat爱吃小鱼干~~~");
}
public void jump() {//8.定义一个子类特有的方法
System.out.println("小猫Cat跳的老高了~~~");
}
}
