java个人学习笔记13（Object+内部类+局部内部类+匿名内部类）

1.查看源代码：java->jdk->src.zip

2.Object

/**
Object:java中最终的父类，即根类
public boolean equals(Object obj)
该类中定义了一些成员方法，包括equals，现重写equals方法
*/
class Person /*extends Object*/{
	private String name;
	private int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}//构造函数
	public boolean equals(Object obj){
		if(!(obj instanceof Person))//对obj的类型进行判断
			throw new ClassCastException("类型错误");
		if(this == obj)
			return true;//提高效率，不用后续的判断
		Person obj1 = (Person) obj;//向下转型，方能调用子类特有的属性
		return (this.name.equals(obj1.name)) && (this.age == obj1.age);
		//String是一个类，其中定义了equals方法，用于字符串的比较，就不要使用“==”
	}
}



class PersonDemo{
	public static void main(String[] args) 
	{
		Person p1 = new Person("xiao ming",20);
		Person p2 = new Person("xiao ming",20);
		System.out.println(p1.equals(p2));//判断对象的内容是否相同
		System.out.println(p1==p2);//判断对象的引用是否相同，即是否是指向同一个对象
	}
}

3.内部类

/**
内部类：将类定义到了另一个类的内部
即：A类要直接访问B类中的成员时，可以将A类定义到B类中，作为B类的内部类存在
访问规则：
内部类可以直接访问外部类的成员
外部类只能通过创建内部类的对象进行访问，一旦内部类私有化后，外部类无法访问内部类了
*/

class Outer{//外部类
	private int num = 1;
	private static int num1 = 2;//静态类访问静态变量
	class Inner{//非静态、非私有内部类
		static final int CONS = 0;//非静态类中只能定义静态常量，不能定义其他静态成员
		void show(){
			System.out.println(num);
		}
	}
	static class Inner1{//静态、非私有内部类
		void show(){//非静态成员方法
			System.out.println(num1);
		}
		static void show1(){//静态成员方法
			System.out.println(num1);	
		}
	}
	
	public void visitInner(){
		new Inner().show();
	}//创建内部类的对象进行访问内部类成员
}
class ClassDemo{
	public static void main(String[] args) 
	{
/***********非静态、非私有的内部类访问1************************************************
		Outer o = new Outer();
		o.visitInner();
************非静态、非私有的内部类访问2************************************************
		Outer.Inner in = new Outer().new Inner();
		//类型为Outer.Inner内部类类型，创建外部类对象.创建内部类对象
		in.show();
************静态、非私有的内部类访问非静态成员******************************************
		Outer.Inner1 in = new Outer.Inner1();//没有创建外部类对象，创建了内部类对象
		in.show();
************静态、非私有的内部类访问静态成员********************************************/
		Outer.Inner1.show1();//无需创建外部或内部类的对象，直接用内部类名的方式使用
	}
}

4.为什么内部类可以直接访问外部类的成员？

因为内部类持有了外部类的引用：(若外部类、内部类和局部有同名变量num)

访问外部类成员：Outer.this.num

访问内部类成员：Inner.this.num

访问局部变量：num

5.局部内部类

class Outer{
	private int num = 1;
	public void method(){
		final int x = 5;
		//局部内部类只能访问被final修饰的局部变量，因为内部类与局部变量的生命周期不同
		//有可能当method方法弹栈后，局部变量x已不存在，但是局部内部类对象的引用仍然存在
		//即局部内部类的对象仍然存在于内存中，此时再调用x就有问题了，所以。。。
		class Inner{//局部内部类
			void show(){
				System.out.println("x= "+x);
				System.out.println("num= "+num);
			}
		}
		Inner in = new Inner();
		in.show();
	}
}
class Demo{
	public static void main(String[] args) 
	{
		Outer o = new Outer();
		o.method();
	}
}

6.匿名内部类：简化书写的内部类

前提：内部类需要继承或者实现外部的类或接口

格式：new 父类or接口() {子类的内容}

实质：匿名内部类其实就是一个子类对象

练习一：

abstract class Father{
	abstract void show();
}
class Outer{
	private int num = 4;
	public void method(){
	new Father(){//Father是抽象类不能建立对象，此处实际上是建立了一个父类的子类对象
		public void show(){
			System.out.println(num);
		}//覆盖抽象类中抽象方法show()
	}.show();//匿名内部类调用show()
	}
}
class Demo{
	public static void main(String[] args) 
	{
		new Outer().method();
	}
}

练习二：

interface Inner{
	abstract void show1();
	abstract void show2();
}
class Outer{
	private int num = 4;
	public void method(){
		Inner in = new Inner(){//匿名内部类实质是一个子类对象，此处为多态，向上转型为Inner
			public void show1(){
				System.out.println("show1.."+num);
			}
			public void show2(){
				System.out.println("show2.."+num);
			}
		};
		in.show1();
		in.show2();
	}
}
class Demo1
{
	public static void main(String[] args) 
	{
		new Outer().method();
	}
}

注意上述两种方法的区别：

class Outer{
	public void method(){
		new Object(){
			public void show(){
				System.out.println("Object的子类对象");
			}
		}.show();//子类对象调用show()
	}
}
/*
class Outer{
	public void method(){
		Object in = new Object(){
			public void show(){
				System.out.println("Object的子类对象向上转型为Object");
			}
		};
		in.show();//错误，in为多态Object型对象不能调用子类的特有方法
	}
}
*/
class Demo2{
	public static void main(String[] args) 
	{
		new Outer().method();
	}
}