第二章：面向对象:多态性、子类对象实例化过程

package com.atguigu.java4;

/*
 * 面向对象特征值之三：多态性
 * 
 * 1.理解多态性：可以理解为一个事务的多种形态。
 * 
 * 2.何为多态性？
 * 		对象的多态性：父类的引用指向子类的对象！
 * 
 * 3.多态的使用：虚拟方法调用
 *  有了对象的多态性后，我们在编译期只能调用父类中声明的方法，但是在运行期，我们实际执行的是子类重写父类的方法。
 *  总结：编译看左边，运行看右边。
 * 
 * 4.多态性的使用前提：①要有类的继承关系 ②要有方法的重写
 * 
 * 5.对象的多态性只适用于方法，不适用于属性（编译和运行都看左边）。
 */
public class PersonTest {
	public static void main(String[] args) {
		// 对象的多态性：父类的引用指向子类的对象！
		Person p1 = new Man();

		Person p2 = new Women();
		// 多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法---虚拟方法调用。
		p1.eat();
		p1.walk();

	}
}

package com.atguigu.java2;

/*
 * 子类对象实例化的过程
 * 1.从结果上来看：（继承性）
 * 		子类继承父类以后，就获取了父类中声明的属性和方法
 * 		创建子类的对象，在堆空间中就会加载所有父类中声明的属性。
 * 
 * 2.从过程上来看：
 * 		当我们通过子类的构造器创建子类对象时，我们一定会直接或者间接的调用其父类的构造器，
 * 进而调用父类的父类的构造器，直到调用java.lang.Object这个类中的空参构造器为止。正因为加载过
 * 所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。
 * 
 * 
 * 明确：虽然创建子类对象时调用了父类的构造器，但是从始至终就创建了一个对象，即为new出来的对象实体。
 * 
 * 
 * 
 * 
 */
public class InstanceTest {

}

package com.atguigu.java;

/*
 * 面向对象特征值之三：多态性
 * 
 * 1.理解多态性：可以理解为一个事务的多种形态。
 * 
 * 2.何为多态性？
 * 		对象的多态性：父类的引用指向子类的对象！
 * 
 * 3.多态的使用：虚拟方法调用
 *  有了对象的多态性后，我们在编译期只能调用父类中声明的方法，但是在运行期，我们实际执行的是子类重写父类的方法。
 *  总结：编译看左边，运行看右边。
 * 
 * 4.多态性的使用前提：①要有类的继承关系 ②要有方法的重写
 * 
 * 5.对象的多态性只适用于方法，不适用于属性（编译和运行都看左边）。
 * 
 * **************************************************************
 * 
 * 6.
 */
public class PersonTest {
	public static void main(String[] args) {
		// 对象的多态性：父类的引用指向子类的对象！

		Person p1 = new Man();

		Person p2 = new Women();
		// 多态的使用：当调用子父类同名同参数的方法时，实际执行的是子类重写父类的方法---虚拟方法调用。
		p1.eat();
		p1.walk();
		System.out.println("****************************");

		// 不能调用子类所持有的方法、属性，因为在编译时调用的是父类的结构
		// p2.earnMoney();
		// 有了对象的多态性以后 ，内存中实际上是加载了子类中特有的属性和方法的，但是由于变量声明为父类类型，导致编译时
		// 只能调用父类中声明的属性和方法，子类中的属性和方法不能被调用。

		// 如何才能调用子类特有的属性和方法？
		// 向下转型，使用强制类型转换符。
		Man m1 = (Man) p1;
		m1.earnMoney();
		m1.isSmoking = true;

		// 使用强转时可能会出现ClassCastException的异常。
		// Women w1 = (Women)p1;

		/*
		 * instanceof关键字的使用:
		 * 
		 * a instanceof A:判断对象a是不是类A的实例。如果是返回true 如果不是就返回false
		 * 
		 * 使用情景，为了避免在向下转型时出现ClassCustException的异常，我们在向下转型之前， 先使用a instanceof
		 * A进行判断。一旦返回true就进行向下转型，如果返回false不进行向下转型。
		 * 
		 * 如果a instanceof A 返回true，a instanceof B也返回true 则B是A的父类。
		 */
		if (p2 instanceof Women) {
			Women w1 = (Women) p2;
			w1.isBeauty = true;
			System.out.println("Womens");
		}

		// 练习：
		// 问题一：编译通过，运行不通过

	}
}

package com.atguigu.java1;

/*
 * java.lang.Object类
 * 1.Object类是所有Java类的根父类
 * 2.如果在类的声明中没有使用extends关键字指明其父类，则默认父类就是java.lang.Object
 * 3.Object类中的功能（属性、方法）就具有通用性。
 * 属性：无
 * 方法：equals()、toString()、getclass() hashCode() 
 * 4.Object只声明了空参构造器
 */
public class ObjectTest {
	public static void main(String[] args) {
		// Order order = new Order();
		// System.out.println(order.getClass().getSuperclass());
	}
}

package com.atguigu.java1;

/*
 * 面试题：== 和equals()的区别
 * 
 * 一、回顾==的使用：
 * ==：运算符
 * 1.可以使用在基本数据类型变量和引用数据类型变量当中。
 * 2.如果比较的是基本数据类型变量（boolean除外）比较两个变量保存的数据是否相等（不一定类型相同）
 *   如果比较的是引用类型数据变量，那么比较的就是变量的地址值是否相同。
 *   
 * 补充：== 符号使用时，必须保证符号左右两边的变量类型必须一致。
 *   
 * 二、equals()方法的使用：
 * 1.是一个方法，不是运算符
 * 2.只适用于引用数据类型！
 * 3.Object类中equals()的定义：
 * 			public boolean equals(Object obj){
 * 				return (obj == this);	
 * 			}
 * 说明：Object类中定义的方法和==的作用是相同的：比较两个对象的地址值
 * 
 * 4.像String、Date、File、包装类都重写了Object类中的equals()方法
 * ，重写以后不是比较两个引用的地址是否相同，而是比较的两个对象的”实体内容“是否相同。
 * 
 * 5.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的试题内容是否相同，
 * 那么我们就需要对Object类中的equals()方法进行重写。
 * 重写的原则：比较两个对象的实体值是否一样。
 * 
 */
public class EqualsTest {
	public static void main(String[] args) {
		// int i = 10;
		// int j = 10;
		// double d = 10.0;
		// System.out.println(i == j);// true
		// System.out.println(i == d);// true,自动类型提升
		// char c = 10;// 对应的是ascma值
		// System.out.println(c == i);// true
		// char c1 = 'A';
		// char c2 = 65;
		// System.out.println(c2 == c1);// true
		// System.out.println("------------------------");
		String s1 = new String("ggg");
		// String s2 = "ggg";
		String s2 = new String("ggg");
		System.out.println(s1 == s2);
		String s3 = "ggg";
		String s4 = "ggg";
		System.out.println(s3 == s4);
		// Customer c3 = new Customer();
		// Customer c4 = new Customer();
		// System.out.println(c3 == c4);
		// System.out.println("------------------------");
		// System.out.println(s1.equals(s2));
		 System.out.println(c3.equals(c4));

	}
}

class Customer {
	String name;
	int age;

	// 重写的原则，比较两个对象的实体内容(即 name和age)是否相同

	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj instanceof Customer) {
			Customer cust = (Customer) obj;
			// 比较一下每个属性是否相同
			if (this.age == cust.age && this.name.equals(cust.name)) {
				return true;
			} else {
				return false;
			}
		}
		return false;
	}
}

package com.atguigu.java1;

import java.util.Date;

/*
 * Object类中toString()方法的使用
 * 1.当我们输出一个对象的引用时，实际上就是调用当前对象的toString()方法。
 * 2.Object类中的toString()方法的定义：
 * 		public String toString(){
 * 			return this.getClass().getName() + "@" + Integer.toHexString(hashCode());	
 * 		}
 * 3.像String、Date、File、包装类等都重写了Object类中的toString方法。
 * 使得在调用对象的toString返回”实体内容“信息。
 * 4.自定义类重写toString方法，当调用此方法时，返回对象的实体内容
 */
public class ToStringTest {
	public static void main(String[] args) {
		com.atguigu.java1.Custome c = new com.atguigu.java1.Custome("李世民", 11);
		System.out.println(c);// com.atguigu.java1.Custome@7852e922
		System.out.println(c.toString());// com.atguigu.java1.Custome@7852e922(虚拟地址，JVM)

		String str = new String("哈哈");
		System.out.println(str);// 哈哈
		Date date = new Date(35345L);
		System.out.println(date);

	}
}

class Custome {
	String name;
	int age;

	public Custome(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String toString() {
		return "Custome [name=" + name + ", age=" + age + "]";
	}

	// 手动实现的重写String方法
	// public String toString(){
	// return "Customer[name" + name + ", age = " + age +"]";
	// }
}

public class ReviewTest {
	 @Test
	 public void test1(){
		 //特别的：
         String s = null;
		 System.out.println(s.toString());//NullPointerException空指针异常
		 System.out.println(s);
	 }
}

package com.atguigu.java2;

import org.junit.Test;

/*
 * Java中的JUnit单元测试
 * 理解：分段进行代码的测试，比较集中，不容易混乱
 * 
 * 步骤：
 * 1.选中当前工程 - 右键选择：build path - add libraries - JUnit4 - 下一步
 * 2.创建Java类进行单元测试。
 * 此时的Java类的要求是：①类是公共的（public）②提供公共的无参构造器
 * 3.此类中声明单元测试方法。方法名>>> xxxTest
 * 此时的单元测试方法：方法的权限修饰符是public,没有返回值，没有形参
 * 
 * 4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test
 * 
 * 5.声明好单元测试方法之后，左键双击单元测试方法名，邮件：run as - JUnti Test
 * 
 * 说明：
 * 1.如果执行结果没有异常：绿条
 * 2.如果执行结果有异常：红条
 * 
 * 
 * 
 */
public class JUnitTest {// 符合要求：①类是公共的（public）②提供公共的无参构造器

	int age = 9;

	@Test
	public void testTest() {
		// 在里面测试代码即可：
		String name = "小白";
		namePrint(name);
		System.out.println(name + "年龄：" + age);

	}

	public void namePrint(String name) {
		System.out.println("name：" + name);
	}
}

package com.atguigu.java2;

import java.time.temporal.IsoFields;

import org.junit.Test;

/*
 * 包装类的使用：
 * 1.java提供了8种基本数据类型对应的包装类，使得基本数据类型变量具有类的特征
 * 
 * 2.掌握的：基本数据类型、包装类、String三者之间的相互转换！
 * 
 * 补充：Java中调用类的方法有两种：对于静态方法（static）可以直接使用类名调用
 * 对于非静态方法只能通过对象.方法的方式调用
 * 
 */
public class WrapperTest {
	// String类型转换为----->基本数据类型和包装类:调用包装类的parseXxx(String str);
	@Test
	public void test5() {
		String s = "123";
		// 可能会报NumberForException的异常
		int num2 = Integer.parseInt(s);
		System.out.println(num2 + 1);

		String str2 = "true";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
	}

	// 基本数据类型和包装类如何转化为---->String类型：调用String重载的valueOf(Xxx xxx);
	@Test
	public void test4() {
		// 方式一：连接运算
		int num1 = 10;
		String str1 = num1 + "";// 通过运算的方式
		boolean b = true;
		// String s = b + "1";
		// System.out.println(s);

		// 方式二：
		float f1 = 12.3F;
		String str2 = String.valueOf(f1);// "12.3"
		System.out.println(str2);
		Double d = new Double(34.4);
		String str3 = String.valueOf(d);
		System.out.println(str3);

		Character c = new Character('f');
		String str4 = String.valueOf(c);
		System.out.println(str4);

	}

	/*
	 * JDK5.0新特性：自动装箱与自动拆箱
	 * 
	 */
	@Test
	public void test3() {
		// int num1 = 10;
		// //基本数据类型--->包装类的对象
		// method(num1);//并不是可以直接赋值，是因为自动装箱与自动拆箱

		// 自动装箱：基本数据类型---->包装类
		int i = 10;
		Integer in = i;
		Integer in2 = 77;// 自动装箱

		boolean b1 = true;
		Boolean bo1 = b1;

		// 自动拆箱：包装类---->基本数据类型
		Integer in3 = 55;
		int i1 = in3;// 自动拆箱
	}

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

	// 包装类转换为----->基本数据类型:调用包装类 的xxxValue()方法
	@Test
	public void test2() {
		Integer in1 = new Integer(12);
		int i1 = in1.intValue();
		System.out.println(i1 + 1);

		Float fl1 = new Float(5476F);
		float f1 = fl1.floatValue();
		System.out.println(f1);
	}

	// 基本数据类型---->包装类：调用包装类的构造器
	@Test
	public void test1() {
		int num1 = 10;
		System.out.println(num1);
		Integer in1 = new Integer(num1);
		System.out.println(in1.toString());// Integer此时的toString()方法已经重写

		Integer in2 = new Integer("110");
		System.out.println(in2.toString());
		// 报异常，只能是放数字
		// Integer in3 = new Integer("110abc");
		// System.out.println(in3.toString());

		Float f1 = new Float(12.3f);
		Float f2 = new Float("12.3");
		System.out.println(f1.toString());
		System.out.println(f2);// 其实是省略了toString()方法

		Boolean b1 = new Boolean(true);
		Boolean b2 = new Boolean("TruE");// true,不区分大小写
		System.out.println(b2);

		// 特殊的：
		Boolean b3 = new Boolean("true123");// false 没有报错
		System.out.println(b3);

		// 特殊的：
		Order order = new Order();
		System.out.println(order.isMale);// false

		System.out.println(order.isFemale);// null
	}
}

class Order {
	boolean isMale;
	Boolean isFemale;
}