常用Object的方法,内部类

一 常用Object的方法

1.1 Object是什么?

        Object 是java提供的根类,所有类有直接或者间接的继承Object,由于与java中继承是可以传递的所以Object中的所有方法是所有类都有的方法.

1.2 equals方法

1.2.1 设计目的

比较两个对象是否相等

1.2.2 和"=="的区别

    使用==比较基本数据类型 可以比较值的大小,但是比较引用类型 只能比较内存地址,而 object中默认的equals方法是比较内存地址的,因为人家又不知道你要比较什么属性?需要根据自己的需求进行覆写即可

eg:
             public boolean equals(Object obj){
                return this ==obj;
             }

例子 

需求:规定id相同和名字相同,就是同一个学生

代码:

public class Equals_01 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String a1="asd";
		String a2="asd";
		System.out.println(a1.equals(a2));//true
		Student s1=new Student(001, "张三");
		Student s2=new Student(001, "张三");
		System.out.println(s1==s2);//false,因为地址s1 和 s2的地址不同
		System.out.println(s1.equals(s2));//名字和学号都相同,才返回true;
	}
}
class Student {
	private int id;
	private String name;
	public Student(int id,String name){
		this.id=id;
		this.name=name;
		
	}

	public String getName(){
		return this.name;
	}
	@Override
	public boolean equals(Object obj){
		//需求:规定id相同,就是同一个学生
		//1 先比较地址,地址一样说明是同一个对象,直接返回true;
		if(this==obj){
			return true;
		}
		//2 说明不是同一个对象,那么需要判断是否是同类,不同类没有可比性
		if(obj instanceof Student){
			//向下转型,否则会丢失子类特有的属性(多态的缺点)
				Student s=(Student)obj;
				if(this.id==s.id && this.name.equals(s.name)){
					return true;
				}
			}
		return false;

}
}

1.3 finalize方法

1.3.1设计目的

JVM四大特性:跨平台     面向对象 多线程 自动垃圾回收

        垃圾:一个对象没有任何引用指向他,该对象就被当成垃圾数据,谁也找不到他.等于说是没有用的资源,浪费空间

1.3.1 finalize方法特点

1 是Object中的方法,也就意味着是所有类对象都有的
2 该方法不需要程序员调用,有系统自动调用
3 当一个对象被回收的时候,会自动调用该对象的finalize方法
4 如果我们手动调用该方法,那么只是一个方法调用而已,并不会被回收

例子

public class Finalize_01 {
public static void main(String[] args) {
	Finalize_01 finalize_01=new Finalize_01();
	finalize_01=null;
	for(int i=1;i<10000000;i++){
		System.gc();//程序员可以"建议"垃圾回收
	}
	//执行结果:day_05._02_Finalize.Finalize_01@7ad74083回收
	//执行结果可能不会每次都出现,所以可以采用多次建议或者增加垃圾的数量
}
@Override
	protected void finalize() 	{
	System.out.println(this+"回收");
}
}

1.4 hashCode方法

1.4.1 设计目的

方法设计目的 返回该对象的字符串表示形式

1.4.2 哈希冲突:  

如果一个对象,取对此hash值,那么值一定相同,但是 不同对象,获取hash值也可能相同 又叫哈希冲突

hashCode 方法就是根据哈希方法得到的一个哈希值
hash算法:是一种安全的加密算法,把不定长的数据改为定长的数据,并不能保证其唯一性
1.4.3 既然有哈希冲突不能保证对象的唯一性,怎么办?
 用equals
1 先比较哈希值,如果不同 则不是同一个对象
2 如果不同,再用equals比较

1.5 toString方法

1.5.1 设计目的

方法设计目的 返回该对象的字符串表示形式

1.5.2 实现原理

        输出一个引用类型的数据的时候 会自动调用该对象的toString方法 ,Object中默认的toString方法是打印该对象的内存地址,如果输出一个对象的时候,不希望打印内存地址,而是打印指定格式的内容,就需要覆写toString方法

例子

public class toString_01 {
	public static void main(String[] args) {
		Person person=new Person(001,"张三",18);
		Person person2=new Person(002, "李四", 19);
		System.out.println(person);//运行结果:姓名:   张三    id:1   年龄  :18
		System.out.println(person2);//运行结果:姓名:   李四    id:2   年龄  :19
}
}
class Person{
	private int id ;
	private String name;
	private int age ;
	public Person(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		
		return "姓名:   "+this.name+"    id:"+this.id+"   年龄  :"+this.age;
	}
} 

二 内部类   

2.1 内部类概念

类体中还有其他的类,这个类就叫做内部类

        当一个类的内部需要有一个完整的结构进行描述,而这个内部的完整结构有只是为了外部类提供服务,此时该类就可以定义成内部类

2.2 内部类优点

可以访问外部内的所有属性,包括私有属性

2.3 内部类的使用

1 .成员内部类 可以看做成员变量

成员内部类特点:
   1 成员内部类,没有static修饰
   2  可以使用权限控制修饰符
   3 成员内部类中可以访问外部类的所有属性
   4 在成员内部类中不能有静态声明
   5 内部类编译之后的类名为  : 外部类类名$内部类类名

例子:

public class OuterClass_01 {
	private static String s1="私有化静态";
	private String s2="私有化成员态";
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OuterClass_01 outerClass_01=new OuterClass_01();
		InnerClass innerClass=outerClass_01.new InnerClass();
		innerClass.m2();//输出结果:私有化静态 私有化成员态
	}
class InnerClass{
//	static int i=1;
//	public static void m1(){}
	public void m2(){
		System.out.println(s1);
		System.out.println(s2);
	}
}
}

2. 静态内部类 可以看做静态变量

静态内部类特点:
      1  静态内部类使用static修饰
      2  可以使用权限控制修饰符
      3  内部类编译之后的类名为:外部类类名$内部类类名
      4  在静态内部类中 成员也能声明,静态也能声明
      5  在静态内部类中,无法直接访问外部类的成员属性,需要对象才可以

例子

public class OuterClass_02 {
	private static String s1="私有化静态";
	private String s2="私有化成员";
	static class InnerClass{
		public void m1() {
			System.out.println(s1);
			// System.out.println(s2);
			// 创建外部类对象才能调用 外部类的成员属性
			OuterClass_02 o = new OuterClass_02();
			System.out.println(o.s2);
		}
//		static int i=1;
//		public static void m1(){}
		public static void m2(){
			System.out.println(s1);
//			System.out.println(s2);
			OuterClass_02 o=new OuterClass_02();
			System.out.println(o.s2);	
		}
	}
	public static void main(String[] args) {
		OuterClass_02.InnerClass.m2();
		InnerClass.m2();//在当前类中类名可以省略
		//创建对象
		InnerClass innerClass=new OuterClass_02.InnerClass();
			//外部类类名可以完全省略
		InnerClass innerClass2=new InnerClass();
		innerClass2.m1();
	}
}

3. 局部内部类 可以看做局部变量(方法中的类,不能写任何的修饰符(static,public等都不能写))

局部内部类特点:

1 局部内部类 : 方法中的类才是局部内部类
2  局部内部类不能有静态声明,并且该类也不允许使用static修饰
3  如果外部方法是成员方法,则该内部类可以直接访问外部类的所有属性
4 如果外部方法是静态方法,则该内部类不能直接访问外部类的成员属性,需要有对象
5 局部内部类也可以直接访问外部方法的局部变量,但是需要加fina修饰,从1.8开始final可以省略
   也就是说 ,如果局部内部类使用了外部方法的局部变量,那么该局部变量也就等于加了final修饰了,     值就不能改了
 6 内部类类名:
         如果多个方法的内部类类名不一致, 那就这样:外部类类名$内部类类名, 
         如果多个方法的内部类类名一致, 就是这样:外部类类名$1内部类类名 , 外部类类名$2内部类      类名 , 外部类类名$3内部类类名...

例子

public class OuterClass_03 {
	private static String s1 = "私有化静态";
	private String s2 = "私有化成员";
	
	public void m1(){
		final int i=100;
		int i2=200;
		class InnerClass {
		//static int x=2;
		public void m3(){
			System.out.println(s1);
			System.out.println(s2);
			System.out.println(i);
			System.out.println(i2);
			// 不能在更改
			// i=2;
			// 局部内部类只能在方法内部使用
			// 创建内部类对象
			InnerClass innerClass = new InnerClass();
			innerClass.m3();
		}
		
	}
	
}
public static void m2(){
		final int a=100;
		int a2=200;
		class InnerClass{
			public void m3(){
				System.out.println(s1);
				//静态方法中的内部类,不能直接访问外部类的成员属性,需要创建外部类对象才行
//				System.out.println(s2);
				OuterClass_03 outerClass_03=new OuterClass_03();
				System.out.println(outerClass_03.s2);
			}
		}
		// 不能在更改
				// i=2;
				// 局部内部类只能在方法内部使用
				// 创建内部类对象
				InnerClass innerClass = new InnerClass();
				innerClass.m3();
				System.out.println("111111");
	}
public static void main(String[] args) {
	OuterClass_03 outerClass_03 = new OuterClass_03();
	outerClass_03.m1();
	m2();
}
}

4. 匿名内部类 可以看做实参    

        下一篇文章见