Object类

（一）Object类

（1）Object的概念，子类继承了Object的方法

1.java.lang.Object是java中所有类的直接父类或者间接父类。
例子：class A{}
class B extends A{}
2.所有类的对象都可以声明成Object引用。
例子：Object o1=new A()
Object o2=new B()

（2）getClass()方法getName()

getClass()方法：返回一个对象的实际类型，实质上是该对象所对应类的class文件对象

public class Student {

	public static void main(String[] args) {
		Student stu=new Student();
		stu.hashCode();
		Object ob=stu;
		//所有类的对象都可以声明成Object引用
		Object ob1=new Student();
		System.out.println(ob1.getClass());
		//getClass()方法，返回一个对象的实际类型，实质上是该对象所对应类的Class文件对象
		System.out.println(stu.getClass());
		//Class对象，实质是Class文件，即该类编译之后产生的二进制字节码文件
		//获取gatClass文件的方法以下两种
		//1.通过对象.getClass
		Class c1=stu.getClass();
		//2.通过类名.Class
		Class c2=Student.class;
		//getName()f返回Class对象的全类名
		System.out.println(c1.getName());
		//getSimpleName():返回Class对象的简类名
		System.out.println(c1.getSimpleName());
	}
	public boolean equals(Object obj)
	{
		return true;
	}
}

输出结果：
ob1.getClass：class com.soft.object.Student
stu.getClass：class com.soft.object.Student
c1.getName：com.soft.object.Student
c1.getSimpleName：Student

（3）equals()方法hashCode()

作用：在equsals()方法对于字符串类型（String）的作用是比较两个字符串是否相等，在用到类的实例对象中（Object）的时候未重写的情况下和"=="等价，比较的是两个对象的地址值，在进行Object.equals重写后比较的是2个对象的属性内容是否相等，例：

public class Animal {
   
	String name;
    int age;
    //通过含参构造方法传参，更改方法属性。
     public Animal(String name, int age) {
		this.name = name;
		this.age = age;
	}
	//重写hashCode()函数
//	@Override
//	public int hashCode() {
//		final int prime = 31;
//		int result = 1;
//		result = prime * result + age;
//		result = prime * result + ((name == null) ? 0 : name.hashCode());
//		return result;
//	}
//重写equals()Object函数
//	@Override
//	public boolean equals(Object obj) {
//		if (this == obj)
//			return true;
//		if (obj == null)
//			return false;
//		if (getClass() != obj.getClass())
//			return false;
//		Animal other = (Animal) obj;
//		if (age != other.age)
//			return false;
//		if (name == null) {
//			if (other.name != null)
//				return false;
//		} else if (!name.equals(other.name))
//			return false;
//		return true;
//	}	
}

这里写一个测试类来测试一下

public class AnimalTest {
	public static void main(String[] args) {
		
		String i="ss";
		String j=new String("ss");
		Animal ani1=new Animal("mark",12);
		Animal ani2=new Animal("mark",12);
		System.out.println(j.equals(i));
		System.out.println(ani1.equals(ani2));//比较属性是否相等
		System.out.println(ani1.hashCode());
		
	}
//手动重写Object，equals()方法此时一定会返回true
//	public boolean equals(Object obj)
//	{
//		return true;
//	}

}
未重写equals()函数以及hashCode(),编译输出的结果：
true
false
2018699554
此时判断字符串为相等，两个实例对象的地址不相等。哈希值为2018699554。
进行重写后输出结果：
true
true
3345410
此时判断字符串为相等，两个实例对象的属性内容相等。哈希值为3345410更加准确。

（4）toString()方法

	public static void main(String[] args) {
        
		Student stu=new Student();
		stu.hashCode();//通过ctrl键可查看方法
		Object ob=stu;
		Object ob1=new Student();
	   //toString():Object中方法，输出对象的全类名以及对象的hasCode的十六进制
		System.out.println(ob.toString());
		System.out.println(stu.toString());
		System.out.println(ob1.toString());
	}
	//重写Object，equals方法
	public boolean equals(Object obj){
		return true;
	}
}
输出结果：
com.soft.object.Student@7852e922
com.soft.object.Student@7852e922
com.soft.object.Student@4e25154f
由结果可知ob，ob1，stu都是指向子类的对象，且ob和stu所存地址一样。

//在类中重写toString()方法主要作用是返回该对象的所有属性值的字符串形式
	@Override
	public String toString() {
		return "Animal [name=" + name + ", age=" + age + "]";
	}	
在测试中的输出结果：
Animal [name=mark, age=12]

（二）String类

（1）创建一个字符串对象

String：在遇到双引号（" "）后会在字符串常量池中创建有序的字符序列，是一个常量不可更改。
两种创建字符串的方式

• 1.String str="abc"; //声明式创建。默认的创建方式。
   -声明式创建字符串的方式，字符串存储的位置在字符串常量池中。
   当再次以这种方式创建字符串，则会直接去字符串常量池中进项匹配，如果又就直接引用，没有就直接在字符串常量池中进行创建。
  

• 2.String str = new String(“”); //创建String的实例对象，new时会在堆和栈中开辟新的内存地址。栈中存放的是对的首地址，堆中存放的是具体值。
  

（2）String类中的常用方法

1.boolean equals()方法

	public static void main(String[] args) {
		String i="ss";
		String j=new String("ss");
		
	//	String j=new String("ss");		
	//	j="ss";
		System.out.println(i==j);
		System.out.println(j.equals(i));
	}
	输出结果：
	false
    true
    若将j改变为程序中屏蔽掉的历程此时输出结果：
    true
    true
    说明此时j声明的堆中并未存放东西，当我们再次对j进行赋值时候此时j指向字符串常量池，并未指向堆地址。

2.char charAt(int pos)//得出pos位置的字符

3.int length()//得出字符串长度

4.String[] split()//按照分隔符建立字符串数组

5.trim()//去掉字符两端空格

6.Sting substring(int begin,intend)//截取字符串

7.startsWith(“字符”)//判断字符串是否以"字符"开头。

8.endsWith(“字符”)//判断字符串是否以"字符"为结尾。

9.compareTo()和compareTolgnoreCse()//比较字符串

10.indexOf()//c查找字符或者子串第一次出现的地方

11.lastindexOf()//查找字符或者子串最后一次出现的地方

12.substring()/字符串截取

13.concat()//连接两个字符串，方法之一

14.replace()//替换，用一个字符在调用字符串中所有出现某个字符的地方进行替换

这里写一个测试代码，供参考。

	public static void main(String[] args) {
		// TODO Auto-generated method stub
          String str1="abc";
          String str2="abc";
          String str3=new String("abc");
          //charAt(int):返回指定位置的字符
          char c=str1.charAt(1);
          System.out.println(c);
//          length():返回字符串 的长度
          System.out.println(str1.length());
          //split("分隔符"):将字符串按照分隔符分割为一个字符串类型的数组
          String str4="What:are:words";
          String[] arrays=str4.split(":");
          for(String s:arrays)
          {
        	  System.out.print(s+"\t");
          }
          String str5="   hello word  ";
          System.out.println(str5.trim());
          
//          startsWith("参数")，判断字符串是否以参数值作为开头。
          System.out.println(str4.startsWith("What"));
          //endsWith("参数")，判断字符串是否以参数值作为结尾。
          System.out.println(str4.endsWith("words"));
          //substring()对字符串进行截取，第一个从下标2到最后，第二个从2到下标4-1.
          String str6=str4.substring(2);
          String str7=str4.substring(2, 4);
          System.out.println(str6);
          System.out.println(str7);
          
          System.out.println(str4.replace("a", "b"));
          
	}

最终输出结果

b
3
What	are	words	hello word
true
true
at:are:words
at
Whbt:bre:words
这里不做解释，请自行对照

15.字符串的拼接

这里介绍String拼接的几种方式，以及StringBuffer、StringBuilder，拼接的方式以及三种类型的差异区别。
String,StringBuffer,StringBuider:

• String：String是不可变长量，一点定义赋值后不能改变常量池或堆中的内容，这样会产生大量不可用字符。使用“+”或者String类中的concat()方法进行拼接。是一种引用类型，可以声明对象。
• StringBuffer:可变长度的字符串，在进行字符串拼接后始终是一个对象，StringBuffer中的方法都是用synchronized进行修饰的表示线程安全的。
• StringBuider是线程不安全对象，线程不安全但效率相对高一些。
  线程安全对象：用synchronized进行修饰的方法或代码块。一次只允许一个线程进行访问。线程安全，但效率低。
  线程不安全对象：没有使用synchronized进行修饰，线程不安全，效率高。
  下面给出演示代码：

public static void main(String[] args) {
		// TODO Auto-generated method stub
      String str9="java";
      String str10="bean";
      System.out.println(str9.toString());
      //直接使用“+”号链接即可
      String str11=str9+str10;
      System.out.println(str11);
      String str12="javabean";
      //此处经过测试知道字符串通过“+”号拼接相当于new String("javabean");一个对象
      System.out.println(str11==str12);
      //concat():拼接字符串，该方法与“+”号一样会创建一个新的字符串指向堆中,,并非字符串常量池中
      String str13=str9.concat(str10);
      System.out.println(str12==str13);
      //StringBuffer:在进行字符串拼接后始终是同一个对象,
      StringBuffer sb = new StringBuffer("Hello");
      StringBuffer sb1=sb;
      
      sb.append(" world");
      //toString()函数输出字符串的内容
      System.out.println(sb.toString());
      System.out.println(sb);
      System.out.println(sb1.toString());
      System.out.println(sb==sb1);
      
      //StringBuider可变长度的字符串，在进行字符串拼接后始终是一个对象，
      StringBuilder sbu=new StringBuilder("tomcat");
      sbu.append("good");
      System.out.println(sbu.toString());
      System.out.println(sbu);
	}
	输出结果：
	java
javabean
false
false
Hello world
Hello world
Hello world
true
tomcatgood
tomcatgood

16.comepareTo()和compareTolgnoreCase()//比较字符

compareTo:按照字典顺序比较两个字符串
str.comparTo(str1)
比较规则：1.先按照字符序列进行逐位比较，只返回第一次出现的不同字符的差值。
如果差值为正整数，表示str1在前，str在后。
2.如果两个字符串长度不同，先按照第一比较规则进行，如果第一次比较规则比完仍然没有不同的字符，则直接 返回字符串的长度差值，如果差值为正数说明长的在前，短的在后。

	public static void main(String[] args) {
		String str="helloa";
		String str1="helL";
		System.out.println(str.compareTo(str1));
		System.out.println(str.compareToIgnoreCase(str1));
	}

17.indexOf()和lastindexOf

• indexOf(ch)：返回字符以及子字符串第一次出现的下标，若没有的话会返回“-1”，找第二或者第三个只需嵌套使用即可。
• lastindexOf(ch)：返回字符以及子字符串最后一次出现的下标，若没有的话会返回“-1”，找第二或者第三个只需嵌套使用即可。
• indexof(int)int指对应字符的ASCII码

18.toLowerCase(),toUpperCase(),转换为小写，转换为大写（）

public static void main(String[] args) {
	 String str5="   Hello Word  ";
     String str6=str.toLowerCase();
	String str7=str.toUpperCase();
}
注意：汉字无法转接大小字符，会

19.Valueof（基本数据类型）

可以将基本数据类型转换为字符串

	  System.out.println( String.valueOf(1234));

20.getBytes()//将字符存储在字节数组中

	       byte[] by= str8.getBytes();//转化为对应的ASCII码值，汉子也可以转化，只不过会输出负数，表示溢出。

21.toCharArray()//将字符串转换为char类型的数组

	      char[] array = str8.toCharArray();

（三）包装类

（1）包装类的概念

概念：封装对应基本数据类型的属性以及相关操作方法。
作业：让java更好的面向对象。
基本数据类型包装类例子：

//获得一个基本数据类型的字节数，位数，最大值，最小值。
println(Byte.BYTES+"\t"+Byte.SIZE+"\t"+Byte.MAX_VALUE+"\t"+Byte.MIN_VALUE);

（2）包装类与String类以及基本数据类型之间的相互转换

1.字符串与基本数据类型之间的转换

基本数据类型转字符串：
1.通过字符串拼接基本数据类型：String str=" "+10086;
2.使用String类中的valueOf()方法，String str=String.valueOf(10086);
3.将基本数据类型转换为封装类对象，通过封装类对象.toString();(效率低，不推荐)

Integer inte=i;
String str = inte.toString();

字符串转基本数据类型：
1.通过基本对应数据类型封装类.parseXXX();

int i= Integer.parseInte(str);

2.通过封装类，先将字符串转为封装类对象。然后通过拆箱操作或者XXXValue();

		String str="123";

		
		//Integer inte =new Integer(str)//将字符串转为封装类
		// int i = inte;//这一步自动的
		int i=Integer.valueOf(str);//这一步等价上面自动拆箱了
 		int i=Integer.valueOf(str).intValue();

2.基本数据类型和封装类

封装类转基本数据类型😭 效果一样
1.自动拆箱

Integer inte =new Integer(123);
int i = inte; //自动拆箱

2.封装类对象.XXXvalue()

Integer inte =new Integer(123);
int i = inte.intvalue();

基本数据类型转封装类😭
1.自动装箱

Integer inte1=100;//这一步的100是在哪里算不算装箱
//int i=100;
//Integer inte1=i;

2.通过封装类.valueOf(基本数据类型)

Integer inte=Integer.valueOf(基本数据类型);

3.通过封装类的构造方法

Integer inte=new Integer(123);

3.字符串和封装类

封装类转字符串
通过封装对象.toString();

Integer inte=new Integer("123"或123)//;
String str=inte.toString();

字符串转封装类😭
通过封装类.valueOf(字符串参数);

String str="123";
Integer inte = Integer.valueOf(str);
//这个是字符串转封装类吗，???
String str="123";
Integer inte=new Integer(str);//构造方法

简单的小测试。

		Integer inte=new Integer(123);
		Integer inte10=123;
		Integer inte1=new Integer(123);
		Integer inte2=123;
		System.out.println(inte == inte1);
		System.out.println(inte == inte2);
		System.out.println(inte10 == inte2);
		输出结果：
		false
        false
        true
         123