JAVA零基础入门第一阶段（11）

1.Object类

概念及常用方法

所有类的祖先类/超类/基类，一个类没有明确继承某个父类，均自动继承Object

Object作为祖先类，起着类的标杆的作用

方法	描述
equals(Object obj)	比较两个对象是否一致
hashCode()	返回该对象的hash值
getClass()	返回该类的字节码文件对象
toString()	返回该对象的字符串表示

方法演示

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

		Object obj1 = new Object();
		Object obj2 = new Object();
		
		/**
		 * equals方法：比较两个对象是否一致
		 * 源码分析：
		 * 	public boolean equals(Object obj) {
		 *      return (this == obj);
		 *  }
		 * 理解：对象==对象，直接比较的是内存地址是否一致 
		 */
		boolean equals = obj1.equals(obj2);
		System.out.println(equals);//false
		
		/**
		 * hashCode方法：获取该对象的hash值
		 * 源码分析：
		 * 	public native int hashCode();//具体实现被java隐私化
		 * 理解：hash值是通过内存地址+算法 计算出的，但是hash值不等同于内存地址
		 */
		int hashCode = obj1.hashCode();
		System.out.println(hashCode);
		
		/**
		 * getClass方法：获取该类的字节码文件对象
		 * 源码分析：
		 * 	public final native Class getClass();//具体实现被java隐私化
		 * 理解：java是面向对象的语言，在此语言里万物皆对象，字节码文件(.class)也不例外，也是个对		 * 象。任意一个类的字节码只加载到内存中一次，所以该类的字节码对象都是相同的
		 */
		Class c1 = obj1.getClass();
		Class c2 = obj2.getClass();
		System.out.println(c1);//class java.lang.Object
		System.out.println(c2);//class java.lang.Object
		System.out.println(c1 == c2);//true
		
		/**
		 * toString方法:获取该对象的字符串表示
		 * 源码分析：
		 * 	public String toString() {
         *		return getClass().getName() + "@" + Integer.toHexString(hashCode());
    	 *	}
    	 * 理解：返回值是 获取该字节码文件对象的名字 + "@" + 对象hash值的十六进制表示
		 */
		System.out.println(obj1);//默认调用toString()
		System.out.println(obj1.toString());
	}
}

深入Object方法

equals：
含义：比较两个对象的内存地址是否一致
标杆作用：比较两个对象是否一致
实际运用：了解了标杆作用，不同的子类比较对象之间是否不同有多种规则，所以不同的子类去重写Object类的equals方法即可

toString
含义：获取对象的字符串表现形式
标杆作用：每个子类的字符串表示形式都不同
实际运用：子类重写toString方法，得到自己想要的字符串表现形式

2.对象转型

简介

引用数据的转型

向上转型：子类 转 父类类型

向下转型：父类 转 子类类型，又称为引用数据类型的强转

对象的向上转型

向上转型就是多态

注意：

1. 可以直接调用父类非私有化属性
2. 可以直接调用父类非私有化方法
3. 可以直接调用子类重写父类的方法

向上转型即多态的缺点：不能调用子类的属性和方法

public  class Test {
     
	public static void main(String[] args) {
     
		
		//向上转型：就是多态
		Father f = new Son();
		
		System.out.println(f.fatherStr);//父类属性
		f.fatherMethod01();//父类方法01
		f.fatherMethod02();//子类重写父类方法02
	}
}
class Father{
     
	String fatherStr = "父类属性";
	
	public void fatherMethod01(){
     
		System.out.println("父类方法01");
	}
	public void fatherMethod02(){
     
		System.out.println("父类方法02");
	}
}
class Son extends Father{
     
	String fatherStr = "子类和父类同名的属性";
	String sonStr = "子类属性";
	
	public void sonMethod(){
     
		System.out.println("子类方法");
	}
	
	@Override
	public void fatherMethod02() {
     
		System.out.println("子类重写父类方法02");
	}
	
}

对象的向下转型

向下转型一定要用instanceof判断对象类型

public  class Test {
     
	public static void main(String[] args) {
     
		
		Animal an = new Dog();//向上转型 
		
		//Cat cat = (Cat) an;//直接向下转型容易造成类型转换异常

		if(an instanceof Dog){
     //判断引用an中指向的对象是否是Dog类
			//向下转型
			Dog dog = (Dog) an;
		}else if(an instanceof Cat){
     //判断引用an中指向的对象是否是Cat类
			//向下转型
			Cat cat = (Cat) an;
		}
	}
}
class Animal{
     //动物类
}
class Dog extends Animal{
     
}
class Cat extends Animal{
     
}

3.final关键字

概念

final - 最终的

作用：final修饰类：类不能被继承

​ final修饰方法：方法不能被重写

​ final修饰变量：不能被重新赋值，变成常量（存储在常量池中）

具体使用

//final class Father{//最终的类：不能被继承
class Father{
     
	
	//public final void method() {//最终的方法：不能被子类重写
	public void method() {
     
		System.out.println("父类方法");
	}
}
class Son extends Father{
     
	@Override
	public void method() {
     
		final int i = 10;
		//i = 100;//不能给常量重新赋值
		System.out.println("重写父类的方法");
	}
}

4.抽象类和抽象方法

概念

抽象类：使用abstract修饰

抽闲方法：使用abstract修饰，该方法没有代码块，交给非抽象的子类去重写

思想：抽象类更像是个模板，规定了非抽象的子类应该要完成怎样的方法。当父类里的方法不好实现而该方法又必须写在父类时，可以选择设置为抽象方法，交给非抽象的子类去实现

什么时候使用抽象方法？
当一个类，应该拥有某个方法，但是这个方法不太好具体的实现，就把该方法变成抽象方法，交给非抽象的子类去实现即可

注意：

1.可以使用new关键字来创建抽象类对象？
不可以使用new来创建抽象类的对象，创建的是匿名子类的对象
2.抽象类中只能有抽象方法？
错，抽象类里可以有非抽象方法
3.抽象类中不可以没有抽象方法？
抽象类里可以没有抽象方法，但是这样没有意义
4.如果父类是抽象类，则子类必须实现父类的抽象方法？
子类如果是抽象类，可以不实现父类的抽象方法
5.抽象类不能有构造方法？
抽象类可以有构造方法
6.抽象类的构造方法的有什么用？
子类可以把数据通过抽闲类（父类）的有参构造初始化数据

具体使用1

abstract class A{
     
	public abstract void methodA();
}
abstract class B extends A{
     
	public abstract void methodB();
}
class C extends B{
     
	@Override
	public void methodB() {
     
		System.out.println("重写抽象B方法");
	}
	@Override
	public void methodA() {
     
		System.out.println("重写抽象A方法");
	}
}

具体使用2

abstract class Person{
     
	public abstract void eat();
}
class Chinese extends Person{
     
	@Override
	public void eat() {
     
		System.out.println("中国人吃山珍海味");
	}
}
class Japanese extends Person{
     
	@Override
	public void eat() {
     
		System.out.println("日本人吃马赛克");
	}
}