第5章面向对象编程（中）

最新推荐文章于 2022-03-27 14:41:14 发布

Jiiaaa

最新推荐文章于 2022-03-27 14:41:14 发布

阅读量120

点赞数

分类专栏： # JavaSE 文章标签： javase

本文链接：https://blog.csdn.net/weixin_40517703/article/details/112840831

版权

JavaSE 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

面试题： == 和 equals() 区别

Object类中toString()的使用：

Java中的JUnit单元测试

包装类的使用

关于包装类使用的面试题

面向对象的特征之二：继承性

一、继承性的好处：

① 减少了代码的冗余，提高了代码的复用性
② 便于功能的扩展
③ 为之后多态性的使用，提供了前提

二、继承性的格式：
class A extends B{}
A:子类、派生类、subclass
B:父类、超类、基类、superclass

2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构，只是因为封装性的影响，使得子类不能以“·”的形式直接调用父类的结构而已。
2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。

子类和父类的关系，不同于子集和集合的关系。
extends：延展、扩展
三、Java中关于继承性的规定：

1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

四、Object类的理解

1. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2. 所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类
3. 意味着，所有的java类具有java.lang.Object类声明的功能。

方法的重写

方法的重写(override / overwrite)
1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写后的方法。
3. 重写的规定：
方法的声明：

           权限修饰符返回值类型方法名(形参列表) throws 异常的类型{
                       //方法体
}
           约定俗成：子类中的叫重写的方法，父类中的叫被重写的方法
① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
    >特殊情况：子类不能重写父类中声明为private权限的方法，在子类中仍然可以写同名同参数列表的方法，此时就不是重写父类的方法了
③ 返回值类型：
    >父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
    >父类被重写的方法的返回值类型是A类，则子类重写的方法的返回值类型可以是A类或A类的子类
    >父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
   ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）

子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

四种访问权限修饰符

super关键字的使用

1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器
3.super的使用：调用属性和方法

3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
3.3 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

4.super调用构造器

4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
4.4 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()
4.5 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"调用父类中的构造器

子类对象实例化过程

子类对象实例化的全过程
1. 从结果上来看：（继承性）
子类继承父类以后，就获取了父类中声明的属性或方法。
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
2. 从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，...
直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以进行调用。

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

面向对象特征之三：多态性

1.理解多态性：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
3. 多态的使用：虚拟方法调用（当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法）。在多态情况下，被重写的父类方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。（动态绑定）
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。
4.多态性的使用前提： ① 类的继承关系 ② 方法的重写
5.对象的多态性，只适用于重写过的方法，不适用于属性（编译和运行都看左边）

方法的重载与重写小结

1.二者的定义细节：略
2.从编译和运行的角度看：

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。 Java 的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为 “早绑定”或“静态绑定
而对于多态，只有等到方法调用的那一刻解释运行器才会确定所要调用的具体方法，这称为 “晚绑定”或“动态绑定。
引用一句Bruce Eckel 的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

instanceof关键字的使用

有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。

如何才能调用子类特有的属性和方法？

向下转型：使用强制类型转换符。（但如果类型不匹配，就会出现ClassCastException的异常。）

a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。

使用情境：为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

当类B是类A的父类时，如果 a instanceof A返回true,则 a instanceof B也返回true.

		if(p2 instanceof Woman){
			Woman w1 = (Woman)p2;
			w1.goShopping();
			System.out.println("******Woman******");
		}
		if(p2 instanceof Man){
			Man m2 = (Man)p2;
			m2.earnMoney();
			System.out.println("******Man******");
		}
		if(p2 instanceof Person){
			System.out.println("******Person******");
		}
		if(p2 instanceof Object){
			System.out.println("******Object******");
		}

Object类

java.lang.Object类
1.Object类是所有Java类的根父类
2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
3.Object类中的功能(属性、方法)就具有通用性。
属性：无
方法（部分）：equals() / toString() / getClass() /hashCode() / clone() / finalize() / wait() / notify() / notifyAll()

4. Object类只声明了一个空参的构造器
面试题：final、finally、finalize的区别？
前两个是关键字常量声明，异常最终处理。最后一个是方法名，就是垃圾回收之前会调用的方法。

面试题： == 和 equals() 区别

一、回顾 == 的使用：
== ：运算符
1. 可以使用在基本数据类型变量和引用数据类型变量中
2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
补充： == 符号使用时，必须保证符号左右两边的变量类型要兼容。

二、equals()方法的使用：
1. 是一个方法，而非运算符
2. 只能适用于引用数据类型
3. Object类中equals()的定义：
public boolean equals(Object obj) {
return (this == obj);
}
说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
5. 通常情况下，我们自定义的类如果使用equals()的话，通常也是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写.

重写的原则：比较两个对象的实体内容是否相同.

答案：

1、== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
2、equals 的话，它是属于 java.lang.Object 类里面的方法，如果该方法没有被重写过默认也是我们可以看到 String 等类的 equals 方法是被重写过的，而且 String 类在日常开发中用的比较多，久而久之，形成了 equals 是比较值的错误观点。
3、具体要看自定义类里有没有重写 Object 的 equals 方法来判断。
4、通常情况下，重写 equals 方法，会比较类中的相应属性是否都相等。

Object类中toString()的使用：

1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
2. Object类中toString()的定义：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode));
}
3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息
4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

Java中的JUnit单元测试

步骤：（以Eclipse为例）

1.选中当前工程 - 右键选择：build path - add libraries - JUnit 4 - 下一步
2.创建Java类，进行单元测试。
此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器
3.此类中声明单元测试方法。
此时的单元测试方法：方法的权限是public,没有返回值，没有形参
4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;
5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test
说明：
1.如果执行结果没有任何异常：绿条
2.如果执行结果出现异常：红条

包装类的使用

1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征

2.基本数据类型、包装类、String三者之间的相互转换

基本数据类型转包装类：调用包装类的构造器

//基本数据类型 --->包装类：调用包装类的构造器
	@Test
	public void test1(){
		
		int num1 = 10;
//		System.out.println(num1.toString());
		Integer in1 = new Integer(num1);
		System.out.println(in1.toString());
		
		Integer in2 = new Integer("123");
		System.out.println(in2.toString());
		
		//报异常
//		Integer in3 = new Integer("123abc");
//		System.out.println(in3.toString());
		
		Float f1 = new Float(12.3f);
		Float f2 = new Float("12.3");
		System.out.println(f1);
		System.out.println(f2);
		
		Boolean b1 = new Boolean(true);
		Boolean b2 = new Boolean("TrUe");
		System.out.println(b2);
		Boolean b3 = new Boolean("true123");
		System.out.println(b3);//false
		
		
		Order order = new Order();
		System.out.println(order.isMale);//false
		System.out.println(order.isFemale);//null
	}

包装类转基本数据类型：调用包装类Xxx的xxxValue()

	//包装类--->基本数据类型:调用包装类Xxx的xxxValue()
	@Test
	public void test2(){
		Integer in1 = new Integer(12);
		int i1 = in1.intValue();
		System.out.println(i1 + 1);
		
		Float f1 = new Float(12.3);
		float f2 = f1.floatValue();
		System.out.println(f2 + 1);
	}

JDK 5.0新特性：自动装箱和自动拆箱

	/*
	 * JDK 5.0 新特性：自动装箱 与自动拆箱
	 */
	@Test
	public void test3(){
//		int num1 = 10;
//		//基本数据类型-->包装类的对象
//		method(num1);
		
		//自动装箱：基本数据类型 --->包装类
		int num2 = 10;
		Integer in1 = num2;//自动装箱
		
		boolean b1 = true;
		Boolean b2 = b1;//自动装箱
		
		//自动拆箱：包装类--->基本数据类型
		System.out.println(in1.toString());
		
		int num3 = in1;//自动拆箱
		
	}

	public void method(Object obj){
		System.out.println(obj);
	}

基本数据类型、包装类转 String类型：调用String重载的valueOf(Xxx xxx)

	//基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)
	@Test
	public void test4(){
		
		int num1 = 10;
		//方式1：连接运算
		String str1 = num1 + "";
		//方式2：调用String的valueOf(Xxx xxx)
		float f1 = 12.3f;
		String str2 = String.valueOf(f1);//"12.3"
		
		Double d1 = new Double(12.4);
		String str3 = String.valueOf(d1);
		System.out.println(str2);
		System.out.println(str3);//"12.4"
		
	}

String类型转基本数据类型和包装类：调用包装类的parseXxx(String s)

	//String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
	@Test
	public void test5(){
		String str1 = "123";
		//错误的情况：
//		int num1 = (int)str1;
//		Integer in1 = (Integer)str1;
		//可能会报NumberFormatException
		int num2 = Integer.parseInt(str1);
		System.out.println(num2 + 1);//124
		
		//只要不能解析成true的字符串，都将解析为false
		String str2 = "true1";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);//false
	}

关于包装类使用的面试题

	//解析：三元运算符中要求表达式1和表达式2应该为同种类型，在编译时会做自动类型提升
	@Test
	public void test1() {
		Object o1 = true ? new Integer(1) : new Double(2.0);
		System.out.println(o1);// 1.0

	}

	@Test
	public void test2() {
		Object o2;
		if (true)
			o2 = new Integer(1);
		else
			o2 = new Double(2.0);
		System.out.println(o2);//1
	}

知识点：

Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了，目的是为了提高效率。出了范围就使用的new的方式创建对象。

	@Test
	public void test3() {
		Integer i = new Integer(1);
		Integer j = new Integer(1);
		System.out.println(i == j);//false：对象的引用不同
		
		//解析：
		//Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[],
		//保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在
		//-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率
		//出了范围就使用的new的方式创建对象。
		
		Integer m = 1;
		Integer n = 1;
		System.out.println(m == n);//true

		Integer x = 128;//相当于new了一个Integer对象
		Integer y = 128;//相当于new了一个Integer对象
		System.out.println(x == y);//false
	}

Jiiaaa

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第5章面向对象编程（中）

面向对象的特征之二：继承性一、继承性的好处： ① 减少了代码的冗余，提高了代码的复用性 ② 便于功能的扩展 ③ 为之后多态性的使用，提供了前提二、继承性的格式： class A extends B{} A:子类、派生类、subclass B:父类、超类、基类、superclass 2.1体现：一旦子类A继承父类B以后，子类A中就获取了...
复制链接

扫一扫