java---内部类

内部类

什么是内部类？
内部类就是定义在java类内部的类。
定义在文件中的类。一个文件中只能有一个公有类，与文件同名，但是也可以定义其它类。
类的修饰：只能是public或者无。一个类文件中，只能有一个定义成public,与文件同名，其它无修饰。

内部类有哪些？
1.成员内部类 2.静态内部类 3.局部内部类 4.匿名内部类

成员内部类

定义在类当中，作为类的成员所存在，可以使用成员访问修饰符。如public private protect 或者空。

如何创建成员内部类的对象？
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
这样就可以创建类的对象了
实例：

package com.situ.chapter1;

public class Student {
    private String name;
   
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    
    }
    public void say(){
	System.out.println("i am a student!");
    }
    public class MidStudent {//成员内部类
	private int age;
	

	public int getAge() {
	    return age;
	}


	public void setAge(int age) {
	    this.age = age;
	}


	public void sayHello(){
	    System.out.println("你好！");
	}
	
    }
}

package com.situ.chapter1;

public class Main {

    public static void main(String[] args) {
	Student student = new Student();
	Student.MidStudent ms =student.new MidStudent();
	ms.sayHello();
	student.say();
    }

}

特点：
1.1.在外部类中，可以直接创建内部类的实例，可以访问内部类的任意（不限修饰符）成员。内部类的成员访问修饰符对外部类不限制，实际上是对其外部类的外部类受限。

1.2.成员内部类，可以任意自由的访问外部类实例的成员，不限访问修饰符。成员内部类持有一个指向其外部类的引用。语法：outer.this.成员

1.3 通过hack的方式，可以间接实现类的多重继承。（利用实现一些接口，使其具有多重属性）

静态内部类

相对于成员内部类而言，其使用static修饰。相当于类的静态成员（类成员）。

如何创建静态内部类的对象？
无须先创建外部类的对象。
语法：Outer.Inner inner = new Outer.Inner(); 如果通过import导入静态内部类，则Outer
可省略。—这适合用在成员访问修饰符为空或public的情况。
但是私有成员也可以被访问，如下代码：

package com.situ.chapter2;

public class Student {
    private static String name;
    
    private static void sayHell0() {
	System.out.println("i am a student!");
    }
    public void method() {
	Teacher t = new Teacher();
	t.sayHello();
	sayHell0();
    }
    
    private static class Teacher{
	private void sayHello() {
	    System.out.println("i am a teacher!");
	}
    }
}

package com.situ.chapter2;

public class Main {

    public static void main(String[] args) {
	 Student stu = new Student();
	 stu.method();
    }

}

即在外部类中定义公有方法去访问内部私有类的私有方法。

特点：

2.1 静态内部类是其所在外部类的静态成员（类成员），可以使用成员访问修饰符。创建对象，无须先创建外部类的实例，直接创建对象即可。
2.2 没有指向其外部类实例的引用，不能访问其所在外部类的普通成员，但是可以任意自由的访问其外部类的静态成员。

局部内部类

在除类的作用域之外的作用域内定义的类，一般定义在方法的内部。不能使用成员访问修饰符。其可见性（有效空间作用域），从类定义位置开始，到其所在作用域结束。其有效时间作用域，从代码执行到定义类的位置开始，一直到代码执行到作用域结束。

package com.situ.chapter3;

public interface Person {
     public String getName();
     public void setName(String name);
     public void eat();
}

package com.situ.chapter3;

public class Student {
    
    public Person sayHello() {
	Person ps = null;
	int a=3;
	if(a>5) {
	    class Point implements Person{//局部内部类实现person接口
		private int x;
		private int y;
		
		
		public int getX() {
		    return x;
		}

		public void setX(int x) {
		    this.x = x;
		}

		public int getY() {
		    return y;
		}

		public void setY(int y) {
		    this.y = y;
		}

		@Override
		public String getName() {
		    
		    return null;
		}

		@Override
		public void setName(String name) {
		}

		@Override
		public void eat() {
		}
		
	    }
	    Point p =new Point();
	    return p;
	}
	return ps;
    }
}

package com.situ.chapter3;

public class Main {

    public static void main(String[] args) {
	Person ps = new Student().sayHello();
	System.out.println(ps);
    }

}

特点：
3.1 仅在局部有效，在其所在作用域内有效。
3.2 使用场景：一、类仅需在局部有意义。二、局部内部类可以继承其它类，或实现接口，使用多态特性，使用接口或父类的引用指向此类的实例。

匿名内部类

使用频率高。
顾名思义，没有名字的内部类。
语法：
超类或接口 变量 = new 超类或接口(){
//类定义
};
使用场景：某个对象只需要创建一次的场景

package com.situ.chapter4;

public interface Person {
    public String getName();
}

package com.situ.chapter4;

public class Main {

    public static void main(String[] args) {
	//匿名内部类
	Person p = new Person() {//这里为什么内new一个接口呢，实际上这里匿名了，使用了内部匿名类

	    @Override
	    public String getName() {
		
		return "张三";
	    }
	    
	};
	
	System.out.println(p.getName());
	
    }

}

特点：在定义类的同时，创建此类的实例，无法第二次创建实例。因为没有类型名称，只能使用超类（祖先类）或接口的引用来指向此内部类的实例。
匿名内部类，必须是继承自其它类，或者实现某接口。