13 内部类 和 Object类

13 内部类 和 Object类

内部类

概述

概念：内部类就是定义在一个类的内部的类，编译之后可生成单独的class文件

根据内部类定义的位置不同：
	成员内部类（相当于成员变量的位置）
	静态内部类（相当于类变量的位置）
	局部内部类（相当于局部变量的位置）
	匿名内部类（是特殊的局部内部类）

成员内部类

位置：定义在类中成员变量的位置

特点：
	1.成员内部类可以访问外部类的私有成员而不破坏封装
	2.成员内部类可以访问外部类的类变量
	3.成员内部类中不可以定义静态成员

成员内部类的对象创建方式：
	第一步：先创建外部类对象
	第二步：通过外部类对象创建内部类对象
	注意：成员内部类对象的创建是依赖于外部类对象的
语法：
	外部类类名  外部类对象名 = new 外部类类名();
	外部类类名.内部类类名  内部类对象名 = 外部类对象名.new 内部类类名();
例如：
		//先创建外部类对象
		Outer outer = new Outer();
		//通过外部类对象创建内部类对象
		Outer.Inner inner = outer.new Inner();
this.:用于解决成员变量和局部变量重名问题
super.：用于解决子父类间成员变量重名问题

关于外部类和内部类中存在成员变量重名问题解决 见案例4
语法：
	外部类类名.this  ----->外部类当前对象的引用
	this.属性名 ------>内部类当前对象的引用
	也可以 内部类类名.this.属性名
案例1：说明特点1
package cn.wzx;

public class Demo {

}

//定义一个普通的类

class Outer{
	
	//外部类私有成员变量
	private int a = 10;
	//外部类私有方法
	private void m2() {
		
	}
	//成员内部类
	class Inner{
		//成员内部类的属性
		
		//内部类的成员方法
		
		public void m1() {
			System.out.println(a);
			m2();
		}
	}
}


案例2：说明特点 2 和  3
package cn.wzx;

public class Demo {

}

//定义一个普通的类

class Outer{
	
	//外部类私有成员变量
	private int a = 10;
	//外部类的类变量
	static int b = 20;
	//外部类私有方法
	private void m2() {
		
	}
	//成员内部类
	class Inner{
		//成员内部类的属性
		int c = 30;
		//内部类的成员方法
		//static int d = 40;
		public void m1() {
			System.out.println(a);
			System.out.println(b);
			System.out.println(c);
			m2();
		}
		
	}
}

案例3：关于 成员内部类对象创建
package cn.wzx;

public class Demo {
	public static void main(String[] args) {
		//先创建外部类对象
		Outer outer = new Outer();
		//通过外部类对象创建内部类对象
		Outer.Inner inner = outer.new Inner();
		
		//通过内部类对象访问内部类的方法属性
		inner.m1();
	}
}

//定义一个普通的类

class Outer{
	
	//外部类私有成员变量
	private int a = 10;
	//外部类的类变量
	static int b = 20;
	//外部类私有方法
	private void m2() {
		
	}
	//成员内部类
	class Inner{
		//成员内部类的属性
		int c = 30;
		//内部类的成员方法
		//static int d = 40;
		public void m1() {
			System.out.println(a);
			System.out.println(b);
			System.out.println(c);
			m2();
		}
	}
}

案例4：关于内部类和外部类成员变量重名问题
package cn.wzx;

public class Demo {
	public static void main(String[] args) {
		//先创建外部类对象
		Outer outer = new Outer();
		//通过外部类对象创建内部类对象
		Outer.Inner inner = outer.new Inner();
		
		//通过内部类对象访问内部类的方法属性
		inner.m1();
	}
}

//定义一个普通的类

class Outer{
	
	//外部类私有成员变量
	private int a = 10;
	//外部类的类变量
	static int b = 20;
	//外部类私有方法
	private void m2() {
		int a = 40;
		System.out.println(a);
	}
	//成员内部类
	class Inner{
		int a = 250;
		//成员内部类的属性
		int c = 30;
		//内部类的成员方法
		//static int d = 40;
		public void m1() {
			int a = 360;
			System.out.println(a);
			System.out.println(Outer.this.a);//10
			System.out.println(Inner.this.a);//250  Inner可以省略
			System.out.println(this.a);//250
			System.out.println(b);//20
			System.out.println(c);//30
			m2();
		}
		
	}
}

静态内部类

位置：相当于类变量的位置

特点：
	1.静态内部类不能 直接 访问外部类的非静态成员，但是可以通过创建外部类的对象通过引用访问 
    
静态内部类创建的对象的步骤：
语法： 外部类类名.内部类类名  内部类对象名 = new  外部类类名.内部类类名();
例如：
		//创建静态内部类的对象
		Outer.Inner inner = new Outer.Inner();
注意：当静态内部类和外部类存在同名静态成员时需要通过类名进行区分 见案例4



案例1：关于 静态内部类的定义
//定义一个普通的类

class Outer{
	
	//静态内部类
	static class Inner{
		
		public void m1() {
			
		}
	}
	
}

案例2：关于 静态内部类访问外部类的非静态成员
package cn.wzx;

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

//定义一个普通的类

class Outer{
	//外部类的成员变量
	int a  = 10;
	//外部类的类变量（静态变量）
	static int b = 20;

	//静态内部类
	static class Inner{
		public void m1() {
			//访问外部类的静态成员
			System.out.println(b);
			//访问外部类的非静态成员
			//System.err.println(a);//不能直接访问
			//如果非要访问外部类的非静态成员
			Outer outer = new Outer();
			System.out.println(outer.a);
		}
	}
}

案例3：关于静态内部类的对象创建

package cn.wzx;

public class Demo {
	public static void main(String[] args) {
		//创建静态内部类的对象
		Outer.Inner inner = new Outer.Inner();
		
		inner.m1();
	}
}

//定义一个普通的类

class Outer{
	//外部类的成员变量
	int a  = 10;
	//外部类的类变量（静态变量）
	static int b = 20;

	
	//静态内部类
	static class Inner{
		int c = 30;
		static int d = 40;
		public void m1() {
			Outer outer = new Outer();
			System.out.println(outer.a);
			//访问外部类的静态成员
			System.out.println(b);//20
			System.out.println(c);//30
			System.out.println(d);//40
		}
	}
}

案例：关于静态内部类和外部类存在同名的静态成员

package cn.wzx;

public class Demo {
	public static void main(String[] args) {
		//创建静态内部类的对象
		Outer.Inner inner = new Outer.Inner();
		
		inner.m1();
	}
}

//定义一个普通的类

class Outer{
	//外部类的类变量（静态变量）
	static int b = 20;
	//静态内部类
	static class Inner{
		int c = 30;
		static int b = 40;
		
		public void m1() {
			System.out.println(Outer.b);//20
			System.out.println(Inner.b);//40
			System.out.println(this.c);
		}
	}	
}

局部内部类

位置：在外部类的方法中定义 相当于局部变量的位置

特点：
	1.局部内部类可以访问外部类的成员（实例变量/实例方法/静态变量/静态方法）
	2.当局部内部类中访问外部类的局部变量 要求外部类的局部变量必须是final修饰的（jdk8之前不能省略final  从jdk8之后可以省略final  但是省略了final也是final修饰的）

注意事项：当局部内部类定义在外部类的静态方法中，局部内部类只能直接访问外部类的静态成员，如果想要访问非静态的必须创建对象通过引用访问，但是这种定义方式不推荐

局部内部类创建对象：局部内部类的对象只能在它所在的外部类方法中创建 见案例2

注意：
当局部内部类中存在成员变量和外部类中的成员变量重名，通过 外部类.this.属性名进行区分 见案例3

局部内部类的好处：如最后的案例，实现了教师类和学校类的强耦合
案例1：关于说明特点1
package cn.wzx;

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

//定义一个普通的类

class Outer{
	//外部类的成员
	int  b = 20;//成员变量
	static int c = 30;//静态成员
	public void m3() {
		
	}
	public static void m4() {
		
	}
	
	public  void  m1() {
		//局部变量
		int a = 10;
		//局部内部类
		class Inner{
			//属性
			
			//方法
			public void m2() {
				System.out.println(b);
				System.out.println(c);
				m3();
				m4();
			}
		}
	}
}


案例2：关于局部内部类对象的创建 和 特点2

package cn.wzx;

public class Demo {
	public static void main(String[] args) {
		Outer outer  = new Outer();
		outer.m1();
	}
}

//定义一个普通的类

class Outer{
	//外部类的成员
	int  b = 20;//成员变量
	static int c = 30;//静态成员
	public void m3() {
		
	}
	public static void m4() {
		
	}
	
	public  void  m1() {
		//局部变量
		final int a = 10;//外部类的局部变量
		//局部内部类
		class Inner{
			//属性
			
			//方法
			public void m2() {
				System.out.println(b);
				System.out.println(c);
				System.out.println(a);//访问的是照片
				m3();
				m4();
			}
		}
		
		//创建局部内部类的对象
		Inner inner = new Inner();
		inner.m2();
	}
}

案例3:关于成员变量重名问题
package cn.wzx;

public class Demo {
	public static void main(String[] args) {
		Outer outer  = new Outer();
		outer.m1();
	}
}

//定义一个普通的类

class Outer{
	//外部类的成员
	int  b = 20;//成员变量
	static int c = 30;//静态成员
	public void m3() {
		
	}
	public static void m4() {
		
	}
	
	public  void  m1() {
		//局部内部类
		class Inner{
			//属性
			int b = 250;
			//方法
			public void m2() {
				System.out.println(Outer.this.b);
			}
		}
		
		//创建局部内部类的对象
		Inner inner = new Inner();
		inner.m2();
	}
}


局部内部类的应用： 
学校类：
	方法：选老师方法  当输入奇数是小高  当输入偶数是小刘

小刘老师类：
	teach（） ：java
小高老师类：
	teach(): 抽烟喝酒 泡妞 烫头

实现一个教学接口：
	teach方法
案例：
package cn.wzx;

public class TestSchool {
	public static void main(String[] args) {
		//获得一个老师
		Teacher teacher = School.getTeacher(4);
		teacher.teach();
	}
}

interface Teacher{
	void teach();
}

class XiaoLiu implements Teacher{

	@Override
	public void teach() {
		System.out.println("小刘 教java");
		
	}
	
}

class XiaoGao implents Teacher{

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println("小高 教 抽烟  喝酒  烫头  泡妞");
	}
	
}

class School{
	//方法  选老师 
	public static Teacher getTeacher(int a) {
		if (a%2==0) {
			return new XiaoLiu();
		}else {
			return new XiaoGao();
		}
	}
}

改进后的案例：只保留了学校一个途径获得老师
案例：
package cn.baizhi.day13;

public class TestSchool {
	public static void main(String[] args) {
		//获得一个老师
		Teacher teacher = School.getTeacher(4);
		teacher.teach();
		
		
	}
}

interface Teacher{
	void teach();
}



class School{
	//方法  选老师 
	public static Teacher getTeacher(int a) {
		
		class XiaoLiu implements Teacher{

			@Override
			public void teach() {
				System.out.println("小刘 教java");
				
			}
			
		}

		class XiaoGao implements Teacher{

			@Override
			public void teach() {
				// TODO Auto-generated method stub
				System.out.println("小高教 抽烟  喝酒  烫头  泡妞");
			}
			
		}
		if (a%2==0) {
			return new XiaoLiu();
		}else {
			return new XiaoGao();
		}
		
	}
}

匿名内部类

匿名内部类：是一种特殊的局部内部类，当一个局部内部类继承一个类或者实现一个接口时就可以定义匿名内部类
条件：局部内部类必须继承一个类 或者实现一个接口

特点：匿名内部类只能创建一次对象，这个对象只能使用一次
案例：
package cn.wzx;

public class TestSchool {
	public static void main(String[] args) {
		//获得一个老师
		Teacher teacher = School.getTeacher(4);
		teacher.teach();
		
		
	}
}

interface Teacher{
	void teach();
}

class School{
	//方法  选老师 
	public static Teacher getTeacher(int a) {
		
		
		if (a%2==0) {
			return new  Teacher() {
				@Override
				public void teach() {
					// TODO Auto-generated method stub
					System.out.println("张三 教java");
				}
			};
		}else {
			return new Teacher() {
				
				@Override
				public void teach() {
					// TODO Auto-generated method stub
					System.out.println("李四 教 抽烟");
				}
			};
		}
	}
}


案例：
package cn.wzx;

public class Demo1 {
	public static void main(String[] args) {
		new  IA(){
			public void  m1(){
				System.out.println("我被执行了");
			}
		}.m1();
		
	}
}


interface IA{
	void m1();
}

Object类

基类 超类  是所有类的父类 上帝类  
Object[] o = {new Animal(),new ShengWu()}
Object类中由几个方法

finalize():（已经过时的方法）
java中有自己的垃圾回收机制 
自动垃圾回收：当内存中存在大量的没有引用的对象的时候 垃圾回收器会自动的进行垃圾回收
手动垃圾回收：System.gc() 去手动的调用，只通知垃圾回收器回收垃圾 但是不一定管用
垃圾：一个对象（堆）没有任何的引用去指向它 

案例：自动垃圾回收案例
package cn.wzx;

public class Demo2 {
	public static void main(String[] args) {
		Student[] students =new Student[99999];
		for (int i = 0; i < students.length; i++) {
			students[i] =new Student();
		}
		for (int i = 0; i < 9999999; i++) {
			new Student();
		}
		System.out.println("执行完了");
	}
}

class Student extends Object{
	protected void finalize() throws Throwable {
		super.finalize();
		System.out.println("垃圾被回收了");
	}
}

=================================================================
getClass():用于得到一个引用中所存放对象的运行时类的类型
案例：
package cn.wzx;

public class Demo5 {
	public static void main(String[] args) {
		Animal animal1 = new Dog();
		Animal animal2 = new Cat();
		
		System.out.println(animal1.getClass());
		System.out.println(animal2.getClass());
	}
}

class Animal{
	
}

class Dog extends Animal{
	
}

class Cat extends Animal{
	
}

==================================================================
toString():是Object类中提供的打印对象字符串形式的方法，一般要对toString方法进行重写，目的为了打印对象的属性信息 
案例：
package cn.wzx;

public class Demo5 {
	public static void main(String[] args) {
		Worker worker = new Worker();
		worker.name = "刘";
		worker.age = 17;
		System.out.println(worker);
	}
}


class Worker extends Object{
	//属性
	String name;
	int age;
	@Override
	public String toString() {
		return "Worker [name=" + name + ", age=" + age + "]";
	}
	
	
}
==================================================================
equals():判断两个对象是否是相等，Object类中的equals方法默认是==  当定义一个类时如果需要通过属性判断两个对象是否是同一个时需要根据需求重写equals方法

注意：判断类型是否是同一个类型的代码必须放在第三步进行判断否则会出现空指针异常
案例：
package cn.wzx;

public class Demo6 {
	public static void main(String[] args) {
		Teacher_java t1 = new Teacher_java("刘",17,88);
		Teacher_java t2 = new Teacher_java("高",250,44);
		Teacher_java t3 = new Teacher_java("洋", 17,88);
		//System.out.println(t1==t3);
		System.out.println(t1.equals(t3));
		System.out.println(t1.equals(t2));
	}
}

class Teacher_java{
	//属性
	String name;
	int age;
	int code;
	public Teacher_java(String name, int age,int code) {
		super();
		this.name = name;
		this.age = age;
		this.code = code;
	}
	
	@Override
	public boolean equals(Object obj) {
		//1
		if (this==obj) {
			return true;
		}
		//2
		if (obj==null) {
			return false;
		}
		//3
		if (this.getClass()!=obj.getClass()) {
			return false;
		}
		
		//4 向下转型
		Teacher_java teacher_java = (Teacher_java) obj;
		//5.
		if (this.name.equals(teacher_java.name)&&this.age==teacher_java.age) {
			return true;
		} else {
			return false;
		}
	}	
}

总结

toString():当想要打印一个对象的属性的字符串信息需要在类中进行重写
equals():当判断两个对象是否为同一个对象（通过属性值进行判断）需要重写

java的垃圾回收机制：自动机制 当垃圾超过机制中的限度就会自动触发垃圾回收器进行垃圾回收