[Java基础] 面向对象编程-中级（七）

一、包

1. 作用

• 区分相同名字的类
• 当类很多时，可以很好的管理类
• 控制访问范围

2.基本语法

package com.package1;

1. package关键字，表示打包
2. com.package1表示包名

package com.package1;

3. 本质/原理

创建不同的的文件夹/目录来保存类文件

4. 命名

命名规则

• 只能包含数字、字母、下划线、小黑点
• 不能以数字开头
• 不能是关键字、保留字

命名规范

• 一般以小写字母+小圆点组成

com.公司名.项目名.业务模块名

常用的包

• java.lang.* //基本包，默认引用，不需要再引用
• java.util.* //系统提供的工具包，工具类
• java.net.* //网络包，网络开发
• java.awt.* //做java的界面开发

5. 如何引用

import 包;

import java.util.Scanner;	//引入一个类Scanner

import java.util.*;	//将java.util包所有都引用了

6. 注意示例

• package的作用是声明当前类所在的包，需要放在类的最上面⚠️
• 一个类最多只有一句package
• import指令位置放在package的下面，类定义的前面，可以有多句且没有顺序要求

二、访问修饰符

1.基本介绍

1. 公开级别：public，对外公开
2. 受保护级别：protected，对子类和同一个包的类公开
3. 默认级别：没有修饰符，对同一个包的类公开
4. 私有级别：private，只对类本身访问

2. 访问范围

3. 注意示例

• 修饰符可以用来修饰类的属性，成员方法以及类
• 只有默认和public可以修饰类
• 成员方法的访问规则和属性完全一样

三、封装‼️

1. 基本介绍

封装就是把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序其他部分只能通过被授权的操作才能对数据进行操作

2. 优点

1. 隐藏实现细节：方法（连接数据库）——> 调用（传入参数）
2. 可以对数据进行验证，保证安全合理

实现步骤

1. 将属性进行私有化prinvat
2. 提供一个共有的set方法，用于对属性判断并赋值
3. 提供一个公共的get方法，用于获取属性的值

四、继承‼️‼️

1. 基本介绍

2. 基本语法

class 子类 extends 父类{
}

• 子类就会自动拥有符类定义的属性和方法
• 父类又叫超类、基类
• 子类又叫派生类

public class Inherit{
	public static void main(String[] args){
		Son s = new Son();
		s.name = "大头";
		System.out.println(s.name);
		System.out.println(s.age);


	}
}
class GrandPa{
	String name = "大头爷爷";
	String hobby = "旅游";

}
class Father extends GrandPa{
	String name = "大头爸爸";
	int age = 39;
	private void fun(){

	}
}
class Son extends Father{
	String name = "大头儿子";
	protected void fun(){

	}
}

3. 优点

• 提高代码复用性
• 提高代码扩展性和维护性

4. 注意‼️

• 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问
• 子类必须调用父类的构造器，完成父类的初始化
• 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则编译不会通过‼️
• 如果希望指定去调用父类的哪个构造器，就要显式调用一下：super(参数列表)
• super在使用时必须放在构造器且必须第一行
• super()和this()都只能放在构造器第一行，因此两个方法不能在构造器共存
• java所有类都是Object的子类
• 父类构造器的调用不限于直接父类，将往上直接追溯到Object类
• 子类最多只能继承一个父类，java是单继承机制

5. 本质‼️

五、super关键字

1. 基本介绍

super代表父类的引用，用于访问父类的属性、方法、构造器

2. 基本语法

1. 访问父类的属性，但不能访问父类的private属性：super.属性名
2. 访问父类的方法，不能访问父类的private方法：super.方法名(参数列表)
3. 访问父类的构造器：super(参数列表)

3. 优点

• 调用父类的构造器：分工明确，父类属性由父类初始化，子类属性由子类初始化
• 当子类中有和父类中的成员重名时，为了访问父类的成员，必须通过super
• super的访问不限于直接父类

4. super和this比较

六、方法重写/覆盖（OVERRIDE）

1. 基本介绍

方法覆盖就是子类有一个方法和父类的某个方法的名称、返回类型、参数都一样，那么我们就说子类的这个方法覆盖了父类的方法

2. 注意示例

• 子类的方法的形参列表、方法名称，要和父类方法的形参列表、方法名称完全一样
• 子类方法的返回类型和父类方法返回类型一样，或者父类返回类型的子类
• 子类方法不能缩小父类方法的访问权限

七、多态‼️

1. 基本介绍

方法或对象具有很多形态。是面向对象的第三大特征，多态是建立在封装和继承基础之上的

public class Poly{
	public static void main(String[] args){
		A a = new B();
		System.out.println(a.age);

		B b = (B) a;
		System.out.println(b.age);

	}
}
class A {
	int age = 1;
	public void fun(){
		System.out.println(1);
	}
}

class B extends A {
	int age = 2;
	public void fun(){
		System.out.println(2);
	}

}

2. 具体体现

1. 方法的多态：重写和重载就体现多态
2. 对象的多态

3. 注意示例

• 一个对象的编译类型和运行类型可以不一致
• 编译类型在定义对象时就确定了，不能改变
• 运行类型是可以改变的
• 编译类型看定义时=的左边，运行类型看=的右边
• 多态的前提是：两个对象存在继承关系

4. 多态向上转型

本质

父类的引用指向了子类的对象

语法

父类类型 引用名 = new 子类类型();

特点

• 编译类型看左边，运行类型看右边
• 可以调用父类中的所有成员（须遵守访问权限）
• 不能调用子类中特有成员
• 最终运行效果看子类的具体体现

Animal animal = new Cat();

5. 多态向下类型

语法

子类类型 引用名 = (子类类型)父类引用

特点

• 只能强转父类的引用，不能强转父类的对象
• 要求父类的引用必须指向的是当前目标类型的对象
• 当向下转型后，可以调用子类类型中所有的成员

Animal animal = new Cat();

Cat cat = (Cat)animal;

6. instanceof比较操作符

用于判断对象的运行类型是否为XX类型或其子类型

public class InstanceOf{
	public static void main(String[] args){
		Object o = new String();
		System.out.println(o instanceof String);

		String s = (String) o;
		System.out.println(s instanceof Object);

		Object os =  s;
		System.out.println(os instanceof String);

		// Object o = new Object();
		// System.out.println(o instanceof String);
	}
}

7. 动态绑定机制‼️‼️

/**
 * java的动态绑定机制
 * 1. 当调用对象方法时，该方法会和该对象的运行类型(内存地址)绑定
 * 2. 当调用对象属性时，没有动态绑定机制
*/
public class DynamicBinding{
	public static void main(String[] args){
		A a = new B();
		System.out.println(a.fun1());
		System.out.println(a.fun2());
	}
}
class A {
	int i = 1;
	public int fun1(){
		return geti() + 10;
	}
	public int fun2(){
		return i + 10;
	}

	public int geti(){
		return i;
	}
}
class B extends A {
	int i = 2;
	// public int fun1(){
	// 	return geti() + 20;
	// }
	// public int fun2(){
	// 	return i + 20;
	// }

	public int geti(){
		return i;
	}
}

8. 多态的应用

1）多态数组：数组的定义类型为父类类型，里面保存的实际元素为子类类型

Person[] persons = new Person[5];
persons[0] = new Student();

class Person{	//父类
}
class Student extends Person{		//子类
}

2）多态参数：定义方法的形参类型为父类类型，实参类型允许为子类类型

八、Object类

1. equals方法

==是一个比较运算符

• ==：既可以判断基本类型，又可以判断引用类型
• ==：如果判断基本类型，判断的是值是否相等
• ==：如果判断引用类型，判断的是地址是否相等
• equals：是Object类中的方法，只能判断引用类型
• 默认判断的是地址是否相等，子类中往往重写该方法

/**
 *	equals重写 
*/
public class Equals{
	public static void main(String[] args){

		Person p1 = new Person("jack",18,'m');
		Person p2 = new Person("jack",18,'m');
		Person p3 = new Student("jack",18,'m',1);
		// System.out.println(p1.equals(p2));	//没有重写equals时，默认比较地址 false
		System.out.println(p1.equals(p2));	//true
		System.out.println(p1.equals(p3));	//true

		System.out.println(p1);
		System.out.println(p2);
		System.out.println(p3);
	}
}
class Person{
	static String name;
	static int age;
	static char gender;

	public boolean equals(Object obj){
		if (this == obj) {
			return true;
		}
		if (obj instanceof Person) {
			Person p = (Person)obj;
			return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
		}
		return false;
	}

	public Person(String name,int age,char gender){
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
}
class Student extends Person {
	static int num;
	public Student(String name,int age,char gender,int num){
		super(name,age,gender);
		this.num = num;
	}
}

2. hashCode方法

• 提高了具有哈希结构容器的效率
• 两个引用，如果指向的是同一个对象，则哈希值是一样的
• 两个引用，如果指向的是不同对象，则哈希值是不一样的
• 哈希值主要根据地址号来的，不能完全将哈希值等价于地址

3. toString方法

• 默认返回：全类名+@+哈希值的十六进制
• 子类往往重写toString方法，打印对象时，会自动调用该对象的toString形式
• 当直接输出一个对象时，toString方法会被默认的调用

System.out.println(monster);

就会默认调用：monster.toString();

4. finalize方法

• 当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作
• 什么时候被回收：当某个对象没有任何引用时，则JVM就认为这个对象是一个垃圾对象，就会使用垃圾回收机制类销毁该对象，在销毁该对象前，会调用finalize方法
• 垃圾回收机制的调用：是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动出发垃圾回收机制

public class Finalize{
	public static void main(String[] args){

		Car car = new Car("小汽车");

		car = null;

		System.gc();
		System.out.println("销毁汽车");
	}
}
class Car{
	static String name;
	public Car(String name){
		this.name = name;
	}

	@Override
	protected void finalize() throws Throwable {
		System.out.println("销毁汽车" + name);
	}
}