Java入门 Day013（Object及一些子类）

1、 Object类

类 Object 是类层次结构的根类。
每个类都使用 Object 作为超类(父类),所有类默认继承该类
所有对象（包括数组）都实现这个类的方法

成员方法:
  	public int hashCode()返回该对象的哈希码值。(哈希表中提供一种算法)	
   	可以理解为地址值(不是实际意义的地址值)Hashtable (java.util)
 	
  	返回值是整数类型
  	输出一个对象名称--->地址值 (类名@十六进制数据)
  		
  	public final Class getClass() :	通过这个方法获取当前类的字节码文件对象 
   					返回此 当前类的运行时类(跟反射有关系)
   					
   	Class类下面有一个方法:
   	public String getName()以 String 的形式返回此 Class 对象所表示的实体名称  		

public class ObjectDemo {
	public static void main(String[] args) {
		
		//创建学生对象
		Student s = new Student() ;
		System.out.println(s.hashCode());//1829164700  哈希码值
		Student s2 = new Student() ;
		System.out.println(s2.hashCode());//2018699554 
		Student s3 = new Student() ;
		System.out.println(s3.hashCode());//1311053135
		
		System.out.println("--------------------------");
		Student s4 = new Student() ;
		Class c = s4.getClass() ;
		System.out.println(c);//class com.qianfeng.object_study.Student
		//public String getName()
		String str = c.getName() ;//获取当前字节码文件对象的全路径名称(包名.类名)
		System.out.println(str);//com.qianfeng.object_study.Student
	}
}

2、toString方法

package com.qianfeng.object_study_02;

//学生类
public class Student extends Object {
	
	 String name ;//姓名
	 int age ;//年龄
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	
	//重写toString()方法
	//自动生成
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}	 
}

package com.qianfeng.object_study_02;

/*
 * 	public String toString():返回该对象的字符串表示
 * 建议所有子类重写该方法(自动生成 alt+shift+s-->s)
 * 
 * 		总结:为了防止输出对象名称,得到地址值---->重写Object类中的toString()方法,获取的是对象中的成员信息
 * 		
 * */
//测试类
public class StudentDemo {

	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student() ;
		//默认输出对象名称 ---->实际底层执行的Object中的toString() 
		//输出对象名称--->得到地址值没有意义(看到当前对象的成员)
		//System.out.println(s);//com.qianfeng.object_study_02.Student@6d06d69c
		
		/*
		 * Integer
		 * 		public static String toHexString(int i):

		 * 	toString()等价于
		 * 		
		 * 	某个对象.getClass().getName() + @ + 	Integer.toHexString(某个对象.hashCode()) ;	
		 * 	
		 *  * */
		//System.out.println(s);
		//重写toString方法之后，获取的是对象中的成员信息
		Student s2 = new Student("高圆圆",39) ;
		Student s3 = new Student("高圆圆",39) ;
		System.out.println(s2==s3);
		
		System.out.println("-----------------");
		String str = s.getClass().getName()+"@"+Integer.toHexString(s.hashCode()) ;
		System.out.println(str);
		
		/*
		 * 通过观察:toString()的源码
		 *  public String toString() {
        			return getClass().getName() + "@" + Integer.toHexString(hashCode());
    		}
		 * */		
	}
}

3、equals方法

package com.qianfeng.object_study_03;

//学生类
public class Student extends Object {
	
	private String name ;
	private int age ;
	private String id;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Student(String name, int age, String id) {
		super();
		this.name = name;
		this.age = age;
		this.id = id;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	

	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", id=" + id + "]";
	}
	//重写后的equals方法
	//Object obj = new Student() ;//多态
	//alt+shift+s-->hashcode_and equals
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (age != other.age)
			return false;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}

package com.qianfeng.object_study_03;

/*
 * public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。 
 * 		形式参数是Object类型,需要传递的是该类对象(Object表示任意类)
 * 		equals底层默认的比较是两个对象的地址值是否相同!
 * 		
 * 逻辑:
 * 	两个对象:
 * 		1)比较s1和s2是否属于同一个类型
 * 		2)s1里面中的name和s2的name比较,如果不一致,返回false
 * 		3)比较年龄是否相同,如果不一致,返回false
 * 		...
 * 		
 * 如果比较两个对象是否"相同",重写equasl方法,因为比较对象地址值没意义.
 * 重写equals方法,比较两个对象的之间的内容是否相同 (自动生成equals方法)
 * 
 * == :
 * 	基本类型:比较的是数值是否相同
 *  引用类型:比较的是地址值是否相同
 * */
public class StudentDemo {
	public static void main(String[] args) {
		
		//Student s1 = new Student("高圆圆",39);
		//System.out.println(s1);
		//Student s2 = new Student("高圆圆",39);
		Student s1 = new Student("高圆圆",39,"9527") ;
		Student s2 = new Student("高圆圆",39,"9527") ;
		
		System.out.println(s1==s2); //false	   比较两个对象的地址值没意义的!
		
		Student s3 = s1 ;
		System.out.println(s3==s1);//true
		/*equals
		 * 源码
		 * public boolean equals(Object obj) {
        		return (this == obj);
    	   }
    	   
		 * */
		//System.out.println("重写之前:"+(s1.equals(s2))) ;//false
		System.out.println("重写之后:"+(s1.equals(s2))) ;//true
		System.out.println("---------------------------");
		//Demo s4 = new Demo();
		//System.out.println(s1.equals(s4));//类型不一致,不能比较(false)
		
	}
}

class Demo{}

4、clone方法

package com.qianfeng.object_study_04;

//学生类
//要使用clone()方法,必须实现一个接口Cloneable
public class Student extends Object implements Cloneable{
	
	private String name ;
	private int age ;
	private String id;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Student(String name, int age, String id) {
		super();
		this.name = name;
		this.age = age;
		this.id = id;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	

	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	
	/*
	 * 重写clone()方法
	 * */
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

}

package com.qianfeng.object_study_04;
/*
 * protected void finalize() throws Throwable(异常类:范围最大的)
 * 		当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法
 * 		什么时候回收不用的对象或者一些变量,在GC空闲时回收...(System类使用)
 * protected Object clone()建并返回此对象的一个副本  (复制该对象中的字段)
                throws CloneNotSupportedException   (浅克隆)
                
           注意:
           	如果此对象的类不能实现接口 Cloneable，则会抛出 CloneNotSupportedException
           	
     Cloneable接口没有成员变量,没有构造方法,没有成员方法,----->标记接口(通用:大部分类自动实现)
 * 
 * */
public class StudentDemo {
	
	public static void main(String[] args) throws CloneNotSupportedException {
		
		Student s = new Student();
		//s = null ; //将对象的引用赋值为null
		//new Student() ; //匿名对象
		
		//setXXX()赋值
		s.setName("张三");
		s.setAge(28);
		s.setId("007");
		//张三---28---007
		System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getId());
		
		//当前对象的类实现了cloneable接口就可以使用clone()方法
		Object obj = s.clone() ; 
		Student s2 = (Student)obj;
		//张三---28---007
		System.out.println(s2.getName()+"---"+s2.getAge()+"---"+s2.getId());
		
		System.out.println("----------------------");
		Student s3 = s;
		System.out.println(s3.getName()+"---"+s3.getAge());
		s3.setName("高圆圆");
		s3.setAge(38);
		s3.setId("008");
		System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getId());
		System.out.println(s3.getName()+"---"+s3.getAge()+"---"+s3.getId());
		System.out.println(s2.getName()+"---"+s2.getAge()+"---"+s2.getId());
	}
}

5、Scanner方法

package com.qianfeng.scanner_study_01;

import java.util.Scanner;

/*
 * 	Scanner :一个可以使用正则表达式来解析基本类型和字符串的简单文本扫描器。
 * 
 *  正则表达式:[a-zA-Z0-9]
 *  	qq:不能数字开头,并且9位
 *  	用户名:有数字或者字母组成.
 *  	密码:符合6-16位的数字或者字母
 *  	确认密码:密码一致
 *  	数字@字母.com
 *  	919081924@qq.com
 *  	数字或字母@字母.com.cn(...)
 *  
 *  创建Scanner对象:
 *  		Scanner sc = new Scanner(System.in) ;
 * 构造方法:
 * 		public Scanner(InputStream source)构造一个新的 Scanner，它生成的值是从指定的输入流扫描的
 * 
 * 成员方法:
 * 		判断功能:
 * 			public boolean hasNextXXX() :针对录入数据之前进行判断,判断下一个录入的数据是否是该xxx类型
 *		获取功能:
 * 			public xxx nextXXX():获取键盘录入的xxx数据
 * */
public class ScannerDemo {
	public static void main(String[] args) {
		
		//InputStream in = System.in ; //抽象类多态
		//使用Scanner构造方法传递参数
		Scanner sc = new Scanner(System.in ) ;
		/*
		 * java.util.InputMismatchException
		 *  输入的数据类型和接收的数据类型不匹配
		 *  如何解决?
		 * */
		
		//加入判断
		if(sc.hasNextInt()) {//判断下一个录入的是否是int类型的数据
			int a = sc.nextInt() ;
			System.out.println(a);
		}else {
			//提示
			System.out.println("您输入的数据和当前类型不匹配");
		}
		
	}
}

package com.qianfeng.scanner_study_01;

import java.util.Scanner; //ctlr+shift+o 导包

/*
 * 键盘录入数据的细节问题：
 * 		windows系统默认换行符号：
 * 			/r/n
 * 分别键盘录入两个int类型
 * 			  两个字符串
 * */
public class ScannerDemo2 {
	
	public static void main(String[] args) {
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入两个int类型
		/*
		 * int a = sc.nextInt() ; int b = sc.nextInt() ;
		 * System.out.println("a:"+a+",b:"+b);
		 */
		/*
		 * String s1 = sc.nextLine() ; String s2 = sc.nextLine() ;
		 * System.out.println("s1:"+s1+",s2:"+s2);
		 */
		
		//先录入字符串,在录入int
		/*
		 * String s = sc.nextLine() ; //windows /r/n int a = sc.nextInt() ;
		 * System.out.println("s:"+s+",a:"+a);
		 */
		//先录入int,在录入字符串
		int a = sc.nextInt() ;  //  /r/n
		
		//创建键盘录入对象
		//Scanner sc2 = new Scanner(System.in) ;
		String s = sc.nextLine() ;
		//String s = sc2.nextLine() ;
		System.out.println("a:"+a+",s:"+s);
		
		//细节:
		/*
		 * 	先录入int,在录入字符串出现字符串数据没有接收,存在windows自带换号符号 /r/n,将换号符号当做字符串录入
		 *  怎么解决方案?
		 *  1)在录入字符串前,创建键盘录入对象  
		 *   
		 *  2) io流的时候,BufferedReader     :流的方式键盘录入
		 *   			readLine() ;
		 *  3)全部都是用String接收,
		 *  String--Integer-->int
		 * */
		
	}
}

6、String

package com.qianfeng.string_study_01;
/*
 * String: java.lang.String  不需要导包
 * 	1)字符串是常量,一旦被赋值,其值(数值)不能被改变.
 *  2)Java 程序中的所有字符串字面值("abc"),都作为此类的实例
 *  		String str = "abc" ; 创建一个字符串对象 值是"abc"
 *  3)字符串是有单个字符组成,由字符数组构造出来的字符串
 *  char[] chs = {'a','b','c'} ;
 *  	计算机底层将字符数组---->byte[] bytes = {97,98,99} ;---->二进制等等
 *  
 *  
 *  如何创建字符串对象?
 *  构造方法:
 *  		String() :空参构造 
 *  		public String(char[] value):传入一个字符数组---->创建字符串对象
 *  		public String(char[] value,  int begin, int count):将字符数组的一部分构造成字符串对象
 *  													count:多个长度
 *  		public String(byte[] bytes):传入一个字节数组---->构造字符串对象
 *  		public String(byte[] bytes, int offset, int length) :将字节数组的一部分转换成字符串
 *  		String(String original) :传入一个字符串值构造字符串对象


 *  获取字符串长度:
 *  	public int length()
 *  
 *  
 *  面试题:
 *  		数组中有没有length()?------>length属性
 *  		字符串中有没有length()?---->有,获取字符串长度,length()
 *  		集合中有没有length()?------>没有,size()获取集合的元素数
 *  
 *  
 * */
public class StringDemo {
	public static void main(String[] args) {
		
		//创建一个String类对象
		String s = new String() ;
		System.out.println("s:"+s); //不是地址值,说明当前String底层重写了Object的toString方法
		System.out.println("length():"+s.length());
		System.out.println("--------------------");
		
		//public String(char[] value):传入一个字符数组---->创建字符串对象
		char[] chs = {'a','b','c','d','爱','圆','圆'} ;
		String s2 = new String(chs) ;
		System.out.println("s2:"+s2); 
		System.out.println("length():"+s2.length());
		System.out.println("--------------------");
		
		//public String(byte[] bytes):传入一个字节数组---->构造字符串对象
		byte[] bytes = {97,98,99,100,101} ;
		String s3 = new String(bytes) ;
		System.out.println("s3:"+s3); 
		System.out.println("length():"+s3.length());
		System.out.println("--------------------");
		
		//public String(char[] value,  int begin, int count):将字符数组的一部分构造成字符串对象
		String s4 = new String(chs,4,3) ;
		System.out.println("s4:"+s4); 
		System.out.println("length():"+s4.length());
		System.out.println("--------------------");
		
		//String(byte[] bytes, int offset, int length) :将字节数组的一部分转换成字符串
		String s5 = new String(bytes,2,3) ;
		System.out.println("s5:"+s5); 
		System.out.println("length():"+s5.length());
		System.out.println("--------------------");
		
		//String(String original) :传入一个字符串值构造字符串对象
		String s6 = new String("hello") ;
		System.out.println("s6:"+s6);
		System.out.println("length():"+s6.length());
		
		String s7 = "hello" ; //hello就是当前String实例
		System.out.println(s6==s7);//false
		//字符串常量池 StringPool
		
	}
}

字符的拼接

package com.qianfeng.string_study_01;

/*
 * 字符串的特点：
 * 		字符串是常量,一旦被赋值,其值(数值)不能被改变.
 * */
public class StringDemo2 {

	public static void main(String[] args) {

		// 创建一个字符串
		String s = "hello";
		s += "world";
		System.out.println(s);// helloworld

	}
}

面试题：

•  String s1 = new String("hello") ;
  

•  String s2 = "hello" ;
  

• s1==s2 ? s1和s2分别内存中创建了几个对象!

public class StringDemo3 {
	
	public static void main(String[] args) {
		String s1 = new String("hello") ;
		String s2 = "hello" ;
		System.out.println(s1==s2);//false		==比较的是地址值
		/*
		 * equals方法在String类中已经被重写,所以比较的是内容是否相同
		 * */
		System.out.println(s1.equals(s2));//true 
	}
}

看程序写结果

/* 字符串变量相加:先开对应自己的空间在常量池中,然后拼接,查看是否存在这个数据,如果存在,返回地址值
 * 字符串常量相加:先进行拼接,在开空间
 * */
public class StringDemo4 {
	public static void main(String[] args) {
		
		String s1 = "hello" ;
		String s2 = "world" ;
		String s3 = "helloworld" ;
		System.out.println(s1==s2);//false  //默认比较的是地址
		System.out.println(s3.equals("helloworld"));//true  String重写equals方法,比较是内容是否相同
		System.out.println(s3==("hello"+"world"));    //true
		//使用反编译工具
		
		System.out.println((s1+s2)==s3); //false  
		System.out.println(s1.equals("hello"));//true
		System.out.println(s2.equals("world"));//true
	}
}