第五章：面向对象编程中
目录
5.1：OOP特征之二：继承性（特征之一见第四章）
5.2：方法的重写
5.3：关键字：super
5.4：子类对象实例化的全过程
5.5：OOP特征之三：多态性
5.6：Object类的使用
5.7：==和equals()的区分
5.8：toString()的使用
5.9：单元测试
5.10：包装类(Wrapper)的使用
5.1：OOP特征之二：继承性（特征之一见第四章）
package com.jiayifeng.java;
/*
* 一：继承性
* 1.1：优点
* ①减少了代码的冗余
* ②便于功能的扩展
* ③为之后多态性的使用，提供了前提
*
* 1.2：继承性的格式
* class A extends B{}
* A:子类、派生类、subclass
* B:父类、超类、基类、superclass
* 1.2.1体现：一旦子类A继承了父类B后，子类A中就获取了父类B中声明的结构：属性、方法
* 特别地：父类中声明为private的属性和方法，子类继承父类以后，仍然认为获取了父类中私有的结构
* 只是因为封装性的影响，使得子类不能直接调用父类的结构而已
* 1.2.2子类继承完父类之后，还可以声明自己的属性和方法：实现功能的拓展
* 子类和父类的关系，与子集和集合的关系不同
*
* 1.3:规定
* ①一个类中可以被多个子类继承
* ②java中类的单继承性：一个类只能有一个父类
* ③java中类的多层继承：子父类是相对的概念
* ④子类直接继承的父类，称为：直接继承；子类间接继承的父类，称为：间接继承
* ⑤子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法
*
* 1.4:说明
* ①如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类
* ②所有的Java类(除java.lang.Object类之外)都直接或间接的继承于java.lang.Object类
* ③意味着，所有的java类具有java..lang.Object类声明的功能
*/
public class Extends {
public static void main(String[] args) {
Person p1 = new Person();
p1.age = 22;
p1.eat();
Student s1 = new Student();
s1.age = 18;
s1.study();
Creature c1 = new Creature();
c1.breath();
c1.toString();
}
}
5.2：方法的重写
package com.jiayifeng.java1;
/*
* 一：方法的重写(override / overwrite)
* 1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
*
* 2.应用：重写以后，当创建子类对象以后，通过子类对象调用父类中的同名参数的方法时，实际调用的是子类重写父类的方法
*
* 3.规定：
* 方法的声明：权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
* //方法体
* }
* 约定俗称：子类中的称为重写的方法，父类中称为被重写的方法
* ①子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
* ②子类重写的方法的权限修饰符不能小于父类被重写的权限修饰符
* >特殊情况：子类不能重写父类中声明为private权限的方法
* ③返回值类型：子类的返回值类型必须与父类的返回值类型一致
* ④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
* 4.子类和父类中的同名同参数的方法要么都声明为非static的(考虑重写)，要么都声明为static的(不是重写)
*/
public class StudentTest {
public static void main(String[] args) {
Student s = new Student("软件工程");
s.eat();
s.walk(10);
s.study();
}
}
5.3：关键字：super
package com.jiayifeng.java3;
/*
* 一：super关键字
* 1.super理解为：父类的
* 2.super可以用来调用属性、方法、构造器
* 3.super的使用：调用属性和方法
* ①我们可以在子类的方法或构造器中，通过使用"super.属性"或"super.方法"的方式，显式的调用
* 父类中声明的属性和方法。但是，通常情况下，我们习惯忽略"super."
* ②特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则
* 必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性
* ③特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则
* 必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法
*
* 4.super的使用：调用构造器
* ①我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
* ②"super(形参列表)"的使用，必须声明在子类构造器的首行
* ③我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"，只能二选一，不可以同时出现
* ④在构造器的首行，没有显式的声明"this()"或"super()"，则默认调用的是父类中空参的构造器
* ⑤在类的多个构造器中，至少有一个类的构造器使用了"super(形参列表)"，调用父类中的构造器
*/
public class SuperTest {
public static void main(String[] args) {
// Person person = new Person("张三"，22);
Student student = new Student("软件工程");
student.show();
Student s1 = new Student("Tom",21,"IT");
s1.show();
}
}5.4：子类对象实例化的全过程
package com.jiayifeng.java4;
/*
* 一：子类对象实例化的全过程
* 1.从结果上来看：（继承性）
* 子类继承父类以后，就获取了父类中声明的属性和方法
* 创建子类的对象，在堆空间中，就会加载所有父类中声明的属性
*
* 2.从过程上来看：
* 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，
* 进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止。正因为
* 加载过所有的父类的结构，所以才看到内存中有父类中的结构，子类对象才可以考虑进行调用
*
* 3.明确
* 虽然创建子类对象时调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象
*
*/
public class InstanceTest {
}
5.5：OOP特征之三：多态性
package com.jiayifeng.java4;
/*
* 一：OOP特征之三：多态性
* 1.理解：一个事物的多种形态
*
* 2.何为多态性：父类的引用指向子类的对象
*
* 3.多态的使用：虚拟方法调用(Virtual Method Invocation)
* 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际
* 执行的是子类重写父类的方法
* 总结：编译，看左边；运行，看右边
*
* 4.多态性的使用前提：
* ①含类的继承关系
* ②含方法的重写
*
* 5.对象的多态性：只适用于方法，不适用于属性（编译和运行都看左边）
*
* 6.instanceof关键字
* ①a instanceof A:判断对象a是否是类A的实例。如果是，返回true；否则，返回false
* ②为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行
* instanceof的判断，一旦返回true，就进行向下转型；如果返回false，不进行向下转型
* ③如果a instanceof A返回true，则a instanceof B也返回true，其中，类B是类A的父亲
*
*/
public class PersonTest {
public static void main(String[] args) {
//对象的多态性：父类的引用指向子类的对象
Person person = new Man();
Person person2 = new Woman();
//多态的使用：当调用子父类同名参数的方法时，实际执行的是子类重写父类的方法 ---虚拟方法调用
person.eat();
person.walk();
person2.eat();
person2.walk();
System.out.println(person.id); //1001
//有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为
//父类类型，导致编译时，只能调用父类中声明的属性和方法，子类特有的属性和方法不能调用
//如何调用子类特有的属性和方法？
//向下转型：使用强制类型转换符
//使用强转时，可能出现ClassCastException的异常
Man m1 = (Man)person;
m1.earnMoney();
m1.isSmoking = true;
//instanceof关键字的使用
if(person2 instanceof Woman) {
Woman w1 = (Woman)person2;
w1.goShopping();
System.out.println("*******Woman*******");
}
}
}
5.6：Object类的使用
package com.jiayifeng.java5;
/*
* 一：Object类的使用
* 1.java.lang.Object类
* Object类是所有Java类的根父类
*
* 2.如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
*
* 3.Object类中的功能（属性和方法）具有通用性
* 属性：无
* 方法：equal() / toString() / getclass() / clone()
*
* 4.Object类只声明了一个空参的构造器
*
*/
public class objectTest {
public static void main(String[] args) {
Order order = new Order();
System.out.println(order.getClass().getSuperclass()); //获取对象的类
}
}
class Order{
}
5.7：==和equals()的区分
package com.jiayifeng.java5;
/*
* 一：面试题：==和equals()的区别
* 1.==运算符
* ①可以使用在基本数据类型变量和引用数据类型变量中
* ②如果比较的是基本数据类型：比较两个变量保存的数据是否相等(不一定类型要相同)
* ③如果比较的是引用数据类型：比较两个对象的地址值是否相等
* ④“==”符号使用时，必须保证符号左右两边的变量类型一致
* 2.equals()方法的使用
* ①是一个方法，而非运算符
* ②只能适用于引用数据类型
* ③Object类中equals()的定义
* public boolean equals(Object obj) {
* return (this == obj);
* }
* 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同，即两个引用
* 是否指向同一个对象实体
*
* 3.像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
* 两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同
*
* 4.通常情况下，我们自定义的类如果使用equal()的话，也通常是比较两个对象的“实体内容”是否相同。那么，我们
* 就需要对Object类中的equal()进行重写
*/
public class EqualTest {
public static void main(String[] args) {
//基本数据类型
int i = 10;
int j = 10;
double d = 10;
System.out.println(i == j); //true
System.out.println(i == d); //true
char c = 10;
System.out.println(i == c); //true
char c1 = 'A'; //ASCII码
char c2 = 65;
System.out.println(c1 == c2); //true
//引用类型
Customer cust1 = new Customer("Tom", 21);
Customer cust2 = new Customer("Tom", 21);
System.out.println(cust1 == cust2); //false（地址值不相同）
System.out.println("****************************************");
System.out.println(cust1.equals(cust2)); //false -> true
}
}
5.8：toString()的使用
package com.jiayifeng.java5;
/*
* 一：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()方法，当调用此方法时，返回对象的“实体内容”
*
*/
public class ToStringTest {
public static void main(String[] args) {
Customer cust1 = new Customer("Tom", 22);
System.out.println(cust1.toString()); //com.jiayifeng.java5.Customer@7c30a502
System.out.println(cust1); //com.jiayifeng.java5.Customer@7c30a502
String string = new String("MM");
System.out.println(string); //MM
}
}
5.9：单元测试
package com.jiayifeng.java5;
import java.security.PublicKey;
import org.junit.Test;
/*
* 一：Java中的JUnit单元测试
* 步骤：
* 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
*
* 说明：
* 如果执行结果没有任何异常：绿条
* 如果执行结果出现异常：红条
*/
public class JUntTest {
int num = 10;
@Test
public void testEquals() {
String s1 = "MM";
String s2 = "MM";
System.out.println(s1.equals(s2));
// ClasssCastException的异常
// Object obj = new String("GG");
// Date date = (Date)obj;
System.out.println(num);
show();
}
public void show() {
num = 20;
System.out.println("show()...");
}
}
5.10：包装类(Wrapper)的使用
package com.jiayifeng.java6;
/*
* 一：包装类的使用
* 1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
*
* 2.基本数据类型、包装类、String三者之间的相互转化
*
*/
import org.junit.Test;
public class WrapperTest {
// 1.基本数据类型 -> 包装类：调用包装类的构造器
@Test
public void test1() {
int num1 = 10;
Integer in1 = new Integer(num1);
System.out.println(in1.toString());
Integer in2 = new Integer("123");
System.out.println(in2.toString());
Boolean boolean1 = new Boolean(true);
Boolean boolean2 = new Boolean("true");
System.out.println(boolean1);
System.out.println(boolean2);
}
// 2.包装类 -> 基本数据类型：调用包装类的xxxValue()
@Test
public void test2() {
Integer in1 = new Integer(12);
int i1 = in1.intValue();
System.out.println(i1 + 1);
}
// 3.JDK 5.0新特性：自动装箱与自动拆箱
@Test
public void Test3() {
// ①自动装箱
int num2 = 10;
Integer in1 = num2;
boolean b1 = true;
Boolean b2 = b1;
// 自动拆箱
System.out.println(in1.toString());
int num3 = in1;
}
// 4.基本数据类型、包装类 -> String类型
@Test
public void Test4() {
int num1 = 10;
// 方式一：连接运算
String str1 = num1 + "";
// 方式二：调用String的valueOf(xxx xxx)
float f1 = 12.3f;
String str2 = String.valueOf(f1);
double d1 = new Double(12.4);
String str3 = String.valueOf(d1);
System.out.println(str2);
System.out.println(str3);
}
// 5.String -> 基本数据类型、包装类：调用包装类parseXxx(String s)
public void Test5() {
String str1 = "123";
int num2 = Integer.parseInt(str1);
System.out.println(num2 + 1);
}
}