Java面向对象基础-4

知识点：

       综合案例

一、综合案例

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跳的老高了~~~");
	}
	
}