第十章面向对象编程（高级部分）

学而时习之！！

已于 2023-02-06 17:21:42 修改

阅读量596

点赞数 1

分类专栏： Java 文章标签： java jvm c#

于 2023-01-11 17:50:06 首次发布

本文链接：https://blog.csdn.net/qq_39667860/article/details/128646197

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

文章目录

第十章面向对象编程（高级部分）

第十章面向对象编程（高级部分）

10.1 类变量和类方法（关键字static）

10.1.1类变量快速入门

思考: 如果,设计一个 int count 表示总人数,我们在创建一个小孩时，就把 count 加 1,并且 count 是所有对象共享的就 ok 了!

package com.hspedu.static_;
	public class ChildGame {
		public static void main(String[] args) {
			//定义一个变量 count, 统计有多少小孩加入了游戏
			int count = 0;
			Child child1 = new Child("白骨精");
			child1.join();
			child1.count++;
			Child child2 = new Child("狐狸精");
			child2.join();
			child2.count++;
			Child child3 = new Child("老鼠精");
			child3.join();
			child3.count++;
			
			//类变量，可以通过类名来访问
			System.out.println("共有" + Child.count + " 小孩加入了游戏...");
			//下面的代码输出什么?
			System.out.println("child1.count=" + child1.count);//3
			System.out.println("child2.count=" + child2.count);//3
			System.out.println("child3.count=" + child3.count);//3
			}
			}
		class Child { //类
			private String name;
			//定义一个变量 count ,是一个类变量(静态变量) static 静态
			//该变量最大的特点就是会被 Child 类的所有的对象实例共享
			public static int count = 0;
			public Child(String name) {
				this.name = name;
			}
			public void join() {
				System.out.println(name + " 加入了游戏..");
		}
}

10.1.2 类变量内存布局

static变量是对象共享，不管static变量在哪里，共识：
（1）static变量是同一个类所以对象共享
（2）static类变量，咋类加载的时候就生成了
10.1.3什么是类变量
在这里插入图片描述
定义类变量：

如何访问类变量？

package com.hspedu.static_;
	public class VisitStatic {
		public static void main(String[] args) {
			//类名.类变量名
			//说明：类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问
			System.out.println(A.name);
			A a = new A();
			//通过对象名.类变量名
			System.out.println("a.name=" + a.name);
			}
		}
		class A {
		  	//类变量
			//类变量的访问，必须遵守 相关的访问权限. public static String name = "韩顺平教育";
			//普通属性/普通成员变量/非静态属性/非静态成员变量/实例变量
			private int num = 10;
}

10.1.4 类变量使用注意事项和细节讨论

在这里插入图片描述

10.1.5类方法基本介绍

在这里插入图片描述
类方法的调用：
类名.类方法或者对象名.类方法名（前提是要符合访问修饰符的访问权限）

//1. 当方法使用了 static 修饰后，该方法就是静态方法
//2. 静态方法就可以访问静态属性/变量

10.1.6类方法经典的使用场景

在这里插入图片描述

10.1.7 类方法使用注意事项和细节讨论

在这里插入图片描述

10.2理解 main 方法语法

10.2.1 深入理解 main 方法

在这里插入图片描述

10.2.2 特别提示：

在 main()方法中，我们可以直接调用 main 方法所在类的静态方法或静态属性。
但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静
态成员。

10.3代码块

10.3.1 基本介绍

在这里插入图片描述

10.3.2 基本语法

在这里插入图片描述

10.3.3 代码块的好处和案例演示

在这里插入图片描述

10.3.4 代码块使用注意事项和细节讨论

在这里插入图片描述

class Test{
	Sample sam1=new Sample("sam1 成员初始化");//
	static Sample sam=new Sample("静态成员 sam 初始化 ");//
	static{
	System.out.println("static 块执行");//
	if(sam==null)System.out.println("sam is null");
}
Test()//构造器
{
	System.out.println("Test 默认构造函数被调用");//
}
}
//主方法
public static void main(String str[])
{
	Test a=new Test();//无参构造器
}
//运行结果， 输出什么内容，并写出. 2min 看看
1. 静态成员 sam 初始化
2. static 块执行
3. sam1 成员初始化
4. Test 默认构造函数被调用

10.4 单例设计模式

10.4.1 什么是设计模式

在这里插入图片描述

10.4.2 什么是单例模式

在这里插入图片描述

10.4.3 单例模式应用实例（难理解！！！！）

在这里插入图片描述

10.4.4 饿汉式 VS 懒汉式

在这里插入图片描述

10.5 final 关键字

10.5.1 基本介绍

在这里插入图片描述

10.5.2 final 使用注意事项和细节讨论

class AA {
	/*
	1. 定义时：如 public final double TAX_RATE=0.08;
	2. 在构造器中
	3. 在代码块中
	*/
	public final double TAX_RATE = 0.08;//1.定义时赋值
	public final double TAX_RATE2 ;
	public final double TAX_RATE3 ;
	public AA() {//构造器中赋值
		TAX_RATE2 = 1.1;
	}
	{//在代码块赋值
		TAX_RATE3 = 8.8;
	}
}

在这里插入图片描述

10.6 抽象类

10.6.1 先看一个问题

在这里插入图片描述

package com.hspedu.abstract_;
public class Abstract01 {
	public static void main(String[] args) {
	}
}
abstract class Animal {
	private String name;
	public Animal(String name) {
	this.name = name;
}
//思考：这里 eat 这里你实现了，其实没有什么意义
//即： 父类方法不确定性的问题
//===> 考虑将该方法设计为抽象(abstract)方法
//===> 所谓抽象方法就是没有实现的方法
//===> 所谓没有实现就是指，没有方法体
//===> 当一个类中存在抽象方法时，需要将该类声明为 abstract 类
//===> 一般来说，抽象类会被继承，有其子类来实现抽象方法. // public void eat() {
// System.out.println("这是一个动物，但是不知道吃什么..");
// }
	public abstract void eat() ;
}

10.6.2 解决之道-抽象类快速入门

在这里插入图片描述

10.6.3 抽象类的介绍

在这里插入图片描述

10.6.4 抽象类使用的注意事项和细节讨论

在这里插入图片描述

package com.hspedu.abstract_;
public class AbstractDetail01 {
	public static void main(String[] args) {
	//抽象类，不能被实例化
	//new A();
	}
	}
//抽象类不一定要包含 abstract 方法。也就是说,抽象类可以没有 abstract 方法
//还可以有实现的方法。
abstract class A {
	public void hi() {
		System.out.println("hi");
	}
	}
	//一旦类包含了 abstract 方法,则这个类必须声明为 abstract
	abstract class B {
		public abstract void hi();
	}
	//abstract 只能修饰类和方法，不能修饰属性和其它的
	class C {
	// public abstract int n1 = 1;
}

10.6.5 抽象类使用的注意事项和细节讨论

在这里插入图片描述

10.7 抽象类最佳实践-模板设计模式

10.7.1 基本介绍

在这里插入图片描述

10.7.2 模板设计模式能解决的问题

在这里插入图片描述

10.7.3 最佳实践

在这里插入图片描述

package com.hspedu.abstract_;
abstract public class Template { //抽象类-模板设计模式
	public abstract void job();//抽象方法
	public void calculateTime() {//实现方法，调用 job 方法
	//得到开始的时间
	long start = System.currentTimeMillis();
	job(); //动态绑定机制
	//得的结束的时间
	long end = System.currentTimeMillis();
	System.out.println("任务执行时间 " + (end - start));
	}
}

public class AA extends Template {
	//计算任务
	//1+....+ 800000
	@Override
	public void job() { //实现 Template 的抽象方法 job
		long num = 0;
		for (long i = 1; i <= 800000; i++) {
			num += i;
		}
}
public class BB extends Template{
	public void job() {//这里也去，重写了 Template 的 job 方法
		long num = 0;
		for (long i = 1; i <= 80000; i++) {
			num *= i;
		}
		}
}
public class TestTemplate {
	public static void main(String[] args) {
	AA aa = new AA();
	aa.calculateTime(); //这里还是需要有良好的 OOP 基础，对多态
	BB bb = new BB();
	bb.calculateTime();
	}
}

10.8 接口

10.8.1 为什么有接口

在这里插入图片描述

10.8.2 接口快速入门

package com.hspedu.interface_;
public interface UsbInterface { //接口
	//规定接口的相关方法,老师规定的.即规范... public void start();
	public void stop();
	}
public class Camera implements UsbInterface{//实现接口,就是把接口方法实现
	@Override
	public void start() {
		System.out.println("相机开始工作...");
	}
	@Override
	public void stop() {
		System.out.println("相机停止工作....");
	}
}
//Phone 类 实现 UsbInterface
//解读 1. 即 Phone 类需要实现 UsbInterface 接口 规定/声明的方法
public class Phone implements UsbInterface {
	@Override
	public void start() {
		System.out.println("手机开始工作...");
	}
	@Override
	public void stop() {
		System.out.println("手机停止工作.....");
	}
}

public class Interface01 {
	public static void main(String[] args) {
		//创建手机，相机对象
		//Camera 实现了 UsbInterface
		Camera camera = new Camera();
		//Phone 实现了 UsbInterface
		Phone phone = new Phone();
		//创建计算机
		Computer computer = new Computer();
		computer.work(phone);//把手机接入到计算机
		System.out.println("===============");
		computer.work(camera);//把相机接入到计算机
	}
}

10.8.3 基本介绍

在这里插入图片描述
JDK8后，可以有默认实现方法，需要使用default关键字修饰

package com.hspedu.interface_;
public interface DBInterface { //项目经理
	public void connect();//连接方法
	public void close();//关闭连接
}
//A 程序
public class MysqlDB implements DBInterface {
	@Override
	public void connect() {
		System.out.println("连接 mysql");
}
	@Override
	public void close() {
		System.out.println("关闭 mysql");
	}
}

//B 程序员连接 Oracle
public class OracleDB implements DBInterface{
	@Override
	public void connect() {
		System.out.println("连接 oracle");
	}
	@Override
	public void close() {
		System.out.println("关闭 oracle");
	}
}

public class Interface03 {
public static void main(String[] args) {
	MysqlDB mysqlDB = new MysqlDB();
	t(mysqlDB);
	OracleDB oracleDB = new OracleDB();
	t(oracleDB);
	}
	public static void t(DBInterface db) {
		db.connect();
		db.close();
	}
}

10.8.4 注意事项和细节

在这里插入图片描述

package com.hspedu.interface_;
public class InterfaceDetail02 {
	public static void main(String[] args) {
		//老韩证明 接口中的属性,是 public static final
		System.out.println(IB.n1);//说明 n1 就是 static
		//IB.n1 = 30; 说明 n1 是 final
		}
	}
interface IB {
	//接口中的属性,只能是 final 的，而且是 public static final 修饰符
	int n1 = 10; //等价 public static final int n1 = 10;
	void hi();
}
interface IC {
	void say();
}

//接口不能继承其它的类,但是可以继承多个别的接口
interface ID extends IB,IC {
}
//接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的
interface IE{}
//一个类同时可以实现多个接口
class Pig implements IB,IC {
	@Override
	public void hi() {
	}
	@Override
	public void say() {
	}
}

10.8.6实现接口 vs 继承类

小结: 当子类继承了父类，就自动的拥有父类的功能
如果子类需要扩展功能，可以通过实现接口的方式扩展. 可以理解实现接口是对 java 单继承机制的一种补充

class LittleMonkey extends Monkey implements Fishable,Birdable {}

在这里插入图片描述

10.8.7 接口的多态特性

在这里插入图片描述
接口的多态体现
//接口类型的变量 if01 可以指向实现了 IF 接口类的对象实例

IF if01 = new Monster();
if01 = new Car();

继承体现的多态
//父类类型的变量 a 可以指向继承 AAA 的子类的对象实例

AAA a = new BBB();
a = new CCC();

package com.hspedu.interface_;
	public class InterfacePolyArr {
		public static void main(String[] args) {
			//多态数组 -> 接口类型数组
			Usb[] usbs = new Usb[2];
			usbs[0] = new Phone_();
			usbs[1] = new Camera_();
			/*
			给 Usb 数组中，存放 Phone 和 相机对象，Phone 类还有一个特有的方法 call（），
			请遍历 Usb 数组，如果是 Phone 对象，除了调用 Usb 接口定义的方法外，
			还需要调用 Phone 特有方法 call
			*/
			for(int i = 0; i < usbs.length; i++) {
				usbs[i].work();//动态绑定.. //和前面一样，我们仍然需要进行类型的向下转型
			if(usbs[i] instanceof Phone_) {//判断他的运行类型是 Phone_
				((Phone_) usbs[i]).call();
					}
				}
			}
		}
	  interface Usb{
		void work();
		}
class Phone_ implements Usb {
	public void call() {
		System.out.println("手机可以打电话...");
	}
	@Override
	public void work() {
		System.out.println("手机工作中...");
		}
	}
class Camera_ implements Usb {
	@Override
	public void work() {
	System.out.println("相机工作中...");
	}
}

10.9 内部类

如果定义类在局部位置(方法中/代码块) :(1) 局部内部类 (2) 匿名内部类
定义在成员位置 (1) 成员内部类 (2) 静态内部类

10.9.1 基本介绍

在这里插入图片描述

10.9.2 基本语法

在这里插入图片描述

10.9.3 内部类的分类

在这里插入图片描述

10.9.4 局部内部类的使用

在这里插入图片描述

10.9.5 匿名内部类的使用(重要!!!)

在这里插入图片描述

10.9.6 匿名内部类的最佳实践

当做实参直接传递，简洁高效

//当做实参直接传递，简洁高效
f1(new IL() {
	@Override
	public void show() {
		System.out.println("这是一副名画~~...");
	}
});

f1()是一个方法，这里把匿名内部类当做实参
10.9.7 成员内部类的使用
在这里插入图片描述

10.9.10 静态内部类的使用

在这里插入图片描述

学而时习之！！

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十章面向对象编程（高级部分）

思考: 如果,设计一个 int count 表示总人数,我们在创建一个小孩时，就把 count 加 1,并且 count 是所有对象共享的就 ok 了!类名.类方法或者对象名.类方法名（前提是要符合访问修饰符的访问权限）如果定义类在局部位置(方法中/代码块) :(1) 局部内部类 (2) 匿名内部类。//父类类型的变量 a 可以指向继承 AAA 的子类的对象实例。定义在成员位置 (1) 成员内部类 (2) 静态内部类。（2）static类变量，咋类加载的时候就生成了。
复制链接

扫一扫

专栏目录