java学习第十三天

常用类

1.object

1.1介绍

• object可以成为基类，超类，是所有类的父类或者祖宗类
• 如果一个类没有手动声明父类，那么它的父类则为object类
• object类型的引用，可以指向任何类型的数据
  • object作为参数类型，可以赋值任何类型的
  • object作为返回类型

package com.qfedu;

public class Student {

	public static void main(String[] args) {
		
		//Object类型的变量，可以指向任何类型的对象
		Object o = new Student();
		
		Object a = new A();
		
		Object b = new B();
		
		//Object作为参数类型，可以赋值任何类型的对象
		useObject(new Student());
		useObject(new A());
		useObject(new B());
		
	}
	
	
	public static void useObject(Object o) {
		
	}
	
	public static Object returnObject() {
		
		return new B();
	}
	
}

class A {
	
}

class B extends A {
	
}

1.2.1 getClass()

package com.qfedu;

public class Demo01 {

	public static void main(String[] args) {
		
		/*
		 * getClass()  获取当前变量的 类对象
		 */
		
		C c = new C();
		System.out.println(c.getClass());  //com.qfedu.C
		
		Object o = new C();
		Class c1 = o.getClass();
		System.out.println(c1);
		
		Object o2 = new D();
		System.out.println(o2.getClass());
		
	}
	
}

class C {
	
}

class D {
	
}

1.2方法

package java.lang;

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }
    
    //获取当前对象的 类对象   如果打印，显示的是类的路径（包.类名）
    public final native Class<?> getClass();

    //返回哈希值，是一种整数的形式，是内存地址的一种表现形式，每个对象都可以自定义自己的算法
    public native int hashCode();

    
    /*
     * 判断两个对象是否相等
       == ： 关系运算符
       		- 比较的是基本类型，比较值
       		- 比较的是引用类型，只有自己和自己比较，结果为true,其他任何情况都为false
       	
      equals : 是方法，方法就可以重写，按照我们自定义的逻辑比较两个对象
      			如果需要重写equals方法，我们一般都是选择属性，自动生成
      			如果重写equals方法，一定也要重写hashCode方法
     */
    public boolean equals(Object obj) {
        return (this == obj);
    }

    /*
     * 克隆方法
     * 相当于复制一份当前对象
     * 需要实现cloneable接口，拥有克隆能力，才能进行克隆
     */
    protected native Object clone() throws CloneNotSupportedException;

    /*
     * 当我们打印一个对象时，默认打印的是该对象执行toString()返回的字符串
     * 我们可以重写toString()方法，选择打印的对象的属性
     */
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    
    /*
     * notify(), notifyAll(), wait(long timeout),wait()
     * 这些都是关于线程的方法
     * 每一个对象，都可以作为锁对象，
     *	wait  - 等待
     *	notify - 唤醒
     */
    public final native void notify();
    public final native void notifyAll();

    public final native void wait(long timeout) throws InterruptedException;

    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

    public final void wait() throws InterruptedException {
        wait(0);
    }
  
    /*
     * 对象销毁的回调方法
     */
    protected void finalize() throws Throwable { }
}

1.2.2 hashCode()

package com.qfedu;

public class Demo02 {

	public static void main(String[] args) {
		
		/*
		 * hashCode() ： 返回对象的哈希值，它是整数，要尽量保证任何两个不同的对象，hash值要不相等
		 * 				该方法可以重写，每个对象都可以自定义自己的hash算法
		 */
		
		String str = "ab";
		
		int hash1 = str.hashCode();
		
		System.out.println(hash1);
		
		E e = new E();
		System.out.println(e.hashCode());
	}
}

class E {
	
	int a;
	int b;
	
	public int hashCode() {
		return 3;
	}
}

/*
 * 自定义一个类
 * 	两个整数属性
 * 重写hashCode方法，返回值为两个整数和的平方减去88
 */

1.2.3 equals()

package com.qfedu;

public class Demo03 {

	/*
	 * equals() 方法： 比较两个对象是否相等
	 * 	可以重写该方法，按照自定义逻辑比较两个对象
	 */
	public static void main(String[] args) {
		F f1 = new F();
		boolean b = f1.equals(1);
		System.out.println(b);
		
		F f2 = new F();
		f2.a = 5;
		F f3 = new F();
		f3.a = 5;
		
		System.out.println(f2.equals(f3));
		System.out.println(f2 == f3);
				
		
		/*
		 * 两个F对象中，属性a的值相等，那么两个对象就想等（equals结果为true）
		 * 
		 */
		System.out.println(f2.equals(2));
	}
}

class F {
	int a;
	
	
    public boolean equals(Object obj) {
    	
    	if (this.getClass() != obj.getClass()) {
    		return false;
    	}
    	
    	F f = (F) obj;
    	
        return this.a == f.a;
    }
	
}

package com.qfedu;

public class Demo03_2 {
	
	/*
	 * equals可以根据我们实际的需求，选择属性，自动生成
	 * 在重写equals时，需要一起把hashCode方法也重写
	 * 	目的：让两个equals结果为true的两个对象，生成的hashCode也相同
	 * 		在Set，Map集合集合达到去重的效果
	 */
	public static void main(String[] args) {
		
		Person p1 = new Person();
		p1.setName("张钧甯");
		p1.setGender("女");
		p1.setCardId("666888");
		
		Person p2 = new Person("高圆圆", "女", "666555");
		
		Person p3 = new Person("高圆圆", "女", "666555");
		
		boolean r = p1.equals(p2);
		
		boolean r2 = p2.equals(p3);
		
		System.out.println(r2);
		System.out.println("p2的hashCode:"+p2.hashCode());
		System.out.println("p3的hashCode:"+p3.hashCode());
		
		
	}
}

class Person {
	
	private String name;
	private String gender;
	private String cardId;  // 身份证
	
	public Person() {  //   alt+/  回车
	}
	
	public Person(String name, String gender, String cardId) {
		this.name = name;
		this.gender = gender;
		this.cardId = cardId;
	}
	
	@Override
	public int hashCode() {
		final int prime = 31;  // 定义一个常量  31
		int result = 1;        //定义一个整数
		result = prime * result + ((cardId == null) ? 0 : cardId.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		//如果自己和自己比较，直接返回true
		if (this == obj) {	
			return true;
		}
		
		//如果比较的为null值，直接返回false
		if (obj == null) {
			return false;
		}
		
		//如果不是同一种数据类型，直接返回false
		if (getClass() != obj.getClass()) {
			return false;
		}
		
		//数据类型转化
		Person other = (Person) obj;
		
		if (cardId == null) {
			if (other.cardId != null) {
				return false;
			}
		} else if (!cardId.equals(other.cardId)) {
			return false;
		} 
			
		return true;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	
	public String getCardId() {
		return cardId;
	}
	public void setCardId(String cardId) {
		this.cardId = cardId;
	}
	
	/*
	 * 定义电脑类
	 * 	属性：品牌，价格，颜色，编号
	 * 
	 *  要求：如果两个电脑编号相同，则视为同一个电脑（两个电脑相等）
	 */
	
}

1.2.4 clone()

package com.qfedu;

public class Demo04 {

	/*
	 * clone() : 克隆方法
	 * - 把当前对象拷贝一份
	 * - 当前类必须实现Cloneable接口
	 */
	public static void main(String[] args) throws CloneNotSupportedException {
		G g = new G();
		g.a = 3;
		g.b = 5;
		
		G g2 = g.getClone();
		
		System.out.println(g2.a+","+g2.b);
	}
}

class G implements Cloneable{
	int a;
	int b;
	
	public G getClone() throws CloneNotSupportedException {
		return (G) this.clone();
	}
}

/*
 * 在电脑中，编写一个方法
 * 	- 返回一个当前对象的克隆对象
 *  - 前提，让电脑类具有克隆功能
 */

1.2.5 toString()

package com.qfedu;

public class Demo05 {

	/*
	 * toString()方法
	 * 
	 * 当我们打印一个对象时，默认打印的是该对象执行toString()返回的字符串
	 * 可以对方法进行重写，打印当前对象的属性值
	 */
	
	public static void main(String[] args) {
		J j = new J(1,6);
		
		System.out.println(j);  //com.qfedu.J@15db9742
		
		String str = j.toString();
		System.out.println(str);  //com.qfedu.J@15db9742 
	}
}

class J {
	
	private int a;
	private int b;
	
	public J() {
		
	}
	
	public J(int a, int b) {
		super();
		this.a = a;
		this.b = b;
	}
	
	public int getA() {
		return a;
	}
	public void setA(int a) {
		this.a = a;
	}
	public int getB() {
		return b;
	}
	public void setB(int b) {
		this.b = b;
	}

	@Override
	public String toString() {
		return "J [a=" + a + ", b=" + b + "]";
	}
	
	/*
	 * 重写Computer类toString() 方法
	 * 打印每一个属性值
	 */
		
}

1.2.6 finalize()

package com.qfedu;

public class Demo06 {
	
	/*
	 * finalize() ： 对象回收的回调方法
	 * - System.gc();  主动垃圾回收
	 * - 被标记为垃圾的对象的前提：没有变量指向该对象
	 */

	public static void main(String[] args) {
		
	//	H h = new H();
		
		new H();
		
		System.gc(); //主动垃圾回收
	}
	
}

class H {
	
	 public void finalize() throws Throwable {
		 System.out.println("我被over了，请记住我！！！");
	 }
}

2.包装类

1.为什么需要包装类

• 很多方法的参数为object，可以赋值基本类型的值，需要把基本类型看作一种引用类型的对象
• 再实际需求中，我们也需要把字符串类型的数据转化为指定基本类型的值的方法，需要指定类

package com.qfedu;

public class Demo01 {

	public static void main(String[] args) {
		String str = "abc";
		str.equals(1);
		
		String numStr = "1";
		String price = "9.9";
		
		String r = numStr + 2;
		
		System.out.println("++++++++++++++++++++");
		
		K k = new K();
		
		double i = 1;
		k.equals(i);
		
		
	}
	
}

class K {

	public boolean equals(Object obj) {
		
		/*
		 * java.lang.Byte 				byte  	
		 * java.lang.Short				short
		 * java.lang.Integer			int
		 * java.lang.Long				long
		 * java.lang.Float				float
		 * java.lang.Double				double
		 * java.lang.Boolean			boolean
		 * java.lang.Character			char
		 */
		System.out.println(obj.getClass());  //  
		
		return true;
	}
	
}

2.自动装箱，拆箱

package com.qfedu;

public class Demo02 {

	public static void main(String[] args) {
		
		/*
		 * 创建包装类对象
		 */
		Integer i = new Integer(1);
		Integer i2 = new Integer("1");
		
		/*
		 * 自动装箱
		 *  把一个基本类型的值，转化为包装类的对象
		 */
		Integer i3 = 5; // 默认执行：Integer.valueOf(5) 返回的是Integer类型的对象		
		
		/*
		 * 自动拆箱
		 * 	把一个包装类的对象，转化为基本类型的值
		 */
		int ii = i3.intValue(); //默认执行： i3.intValue() 返回的是int类型的数据
		
		
		/*
		 * double类型对应的包装类 Double
		 */
		
		Double d1 = new Double(1.1);
		
		Double d2 = 1.2; // Double.valueOf(1.2); --- new Double(1.2);   // 自动装箱
		
		double dou = d2; // d2.doubleValue();   // 自动拆箱
		
		
		/*
		 * long类型对应的包装类 Long
		 */
	}
}

3.String转化为基本类型

package com.qfedu;

public class Demo03 {

	public static void main(String[] args) {
		
		String num = "3";
		
		/*
		 * 把字符串类型的数据，转化为基本类型的数据
		 */
		byte b = Byte.parseByte(num);
		short s = Short.parseShort(num);
		
		int i = Integer.parseInt(num);
		long l = Long.parseLong(num);
		
		
		String price = "9.9";
		float f = Float.parseFloat(price);
		double d = Double.parseDouble(price);
		
		
		String bo = "true";
		
		boolean boo = Boolean.parseBoolean(bo);  //ctrl+1
		
		
	}
}