内部类

内部类：

1、概念：
在类的内部定义一个完整类
2、特点：
内部类访问外部类不破坏封装，独立生成字节码文件，为外部类提供组件
3、分类：
成员、静态、局部、匿名四种
成员：
级别与成员变量实例方法相同， 创建依附外部类，内部不能定义静态成员。
写法：例如外部类Outer，内部类Inner
Outer o = new Outer(); Outer.Inner i = out.new Inner();
静态:
不依赖外部类,可直接创建或引用
写法：例如外部类Outer，内部类Inner
Outer.Inner.静态成员 Outer.Inner = new Outer.Inner();
局部:
用于隐藏类的信息和限制类的使用范围。
定义在外部类方法中，作用范围创建对象范围仅限当前方法内，访问外部成员变量时外部成员默认fanil用于保障生命周期
匿名:
没有类名的局部类，定义实现创建对象语法合并且只能创建一个对象，必须做实现

作业：
2、

public class TestStudent {
	public static void main(String[] args) {
		Student stu1 = new Student();
		Student stu2 = new Student(18 ,"tom");
		System.out.println(stu1); //toString被重写且未传参，返回均为默认值，输出null 0
		System.out.println(stu2); //toString被重写且传参，输出tom 18	
	}
}
class Student{
	private int age;
	private String name;
	public Student() {}
	public Student(int age , String name) {
		this.age = age;
		this.name = name;
	}
	public String toString() {  //重写toString
		return name + "\t" + age;
	}
}

3、

public class TestEquals {
	public static void main(String[] args) {
		String str1 = new String("hello");
		String str2 = new String("hello");
		System.out.println(str1.equals(str2));  //equals比较相同对象内容
		System.out.println(str1 == str2);  //== 比较对象地址（哈希码）
	}
}

4、

public class TestGetClass {
	public static void main(String[] args) {
		Animal a1 = new Dog();
		Animal a2 = new Animal();
		System.out.println(a1 instanceof Animal);  //判断类型是否相同，输出true
		System.out.println(a1.getClass() == a2.getClass());  // 判断地址是否相同 ， 输出false
	}
}
class Animal{}
class Dog extends Animal{}

六、

public class TestWorker {
	  public static void main(String[] args) {		
	    Worker[] workers = new Worker[] {				
	    new Worker("xm",18,"男",6000.0),				
	    new Worker("xh",19,"女",5000.0),				
	    new Worker("xz",20,"男",7000.0)};		
	    for(int i = 0 ;i < workers.length ; i++) {	
	      System.out.println(workers[i].toString());		
	  }		
	      System.out.println(workers[0].equals(workers[1]));	
	      System.out.println(workers[0].equals(workers[2]));	
	  }
}
    class Worker{	
          String name;	
          int age;	
          String sex;	
          double salary;	
          public Worker() {}	
          public Worker(String name, int age, String sex, double salary) {
          		super();	
             	this.name = name;		
             	this.age = age;		
             	this.sex = sex;		
             	this.salary = salary;	
           }
           	public String toString() {	
           		return name + "\t" + age + "\t" + sex + "\t" + salary;	
            }	
            public boolean equals(Object obj) {	
            	if (this == obj) {		
            		return true;	
             	}			
             	if (obj == null) {			
             	    return false;		
             	}		
             	if (this.getClass() != obj.getClass()) {
             		return false;		
             	}		
             	Worker worker = (Worker) obj;		
             	if (this.name.equals(worker.name) && this.age == worker.age && this.sex.equals(worker.sex) && this.salary == worker.salary) {
             		return true;		
             	}		
             	  return false;	
          }		
  }

9、

public class TestGetClass {
  public static void main(String[] args) {
  	
  }
}
class QuterClass{
  private int value1 = 100;
  private static int value2 = 200;
  public void method(int value3) {
  	final int value4 = 400;
  	class InnerClass{
  		public void print() {
  			System.out.println(value1);
  			System.out.println(value2);
  			System.out.println(value3);
  			System.out.println(value4);
  		}
  	}
  }
}

10、

public class TestLamp {
	public static void main(String[] args) {
		Lamp lamp = new Lamp();
		//局部内部类输出
		class Red implements Light{
			public void shine() {
				System.out.println("shine in red");
			}
		}
		lamp.on(new Red());
		//匿名内部类输出
		lamp.on(
				new Light() {
					public void shine() {
						System.out.println("shine in yellow");
					}
				});
	}
}
interface Light{
	void shine();
}
class Lamp{
	public void on(Light light) {
		light.shine();
	}
}