- 局部匿名类
/*局部内部类*/
/*它是嵌套在方法和作用于内的，对于这个类的使用主要是应用与解决比较复杂的问题，想创建一个类来辅助我们的解决方案，到那时又不希望这个类是公共可用的，所以就产生了局部内部类，
局部内部类和成员内部类一样被编译，只是它的作用域发生了改变，它只能在该方法和属性中被使用，出了该方法和属性就会失效。*/
/*定义在方法里*/
public class Games {
private int code;
public Games(int code){
this.code = code;
}
public SystemRun game1Run(String howToRun){
/*定义在方法里的局部内部类*/
class System4Game1 implements SystemRun{
private String howToRun;
private System4Game1(String howToRun){
defineHowToRun(howToRun);
}
@Override
public void defineHowToRun(String howToRun) {
this.howToRun = howToRun;
System.out.println(this.howToRun);
}
}
if(code == 1){
/* 定义在作用域内的局部内部类*/
class daojishi{
private int time;
public daojishi(int time){
this.time = time;
}
public void countSecond(){
for(int i = 0;i<=time;i++){
System.out.println("倒计时 : "+(time-i));
}
}
}
daojishi ds = new daojishi(10);
ds.countSecond();
}
return new System4Game1(howToRun);
}
public static void main(String[] args) {
Games games = new Games(1);
SystemRun systemRun = games.game1Run("该游戏需要下载插件");
}
}
interface SystemRun{
void defineHowToRun(String howToRun);
}
- 静态内部类
public class Room {
private static int numberId = 1;
enum DOOR_STATUS{
CLOSED,
OPEN
}
/**
*静态内部类
*/
static class ClosedDoor{
/* 在静态内部类中可以存在静态成员 */
static DOOR_STATUS status = DOOR_STATUS.CLOSED;
void dispaly(){
/*
* 静态内部类只能访问外围类的静态成员变量和方法
* 不能访问外围类的非静态成员变量和方法
*/
System.out.println("房间 : " + numberId +" | 此门常闭");
}
}
/**
* 非静态内部类
*/
class MovableDoor{
/* 非静态内部类中不能存在静态成员 */
DOOR_STATUS status;
public MovableDoor(DOOR_STATUS status){
this.status = status;
}
/* 非静态内部类中可以调用外围类的任何成员, === 》 不管是静态的还是非静态的 《 === */
String getStatus(){
switch (status){
case OPEN:
return "关闭";
case CLOSED:
return "开着";
default:
return "不知道";
}
}
public void dispaly(){
System.out.println("活动门状态 : "+getStatus());
}
}
MovableDoor getMovableDoor(DOOR_STATUS status){
return new MovableDoor(status);
}
public static void main(String[] args) {
/* 外围类访问静态内部类：内部类. */
System.out.print(ClosedDoor.status.toString() + " | ");
/* 静态内部类 可以直接创建实例不需要依赖于外围类 */
ClosedDoor closedDoor = new ClosedDoor();
closedDoor.dispaly();
Room room = new Room();
/* 非静态内部的创建需要依赖于外围类 */
Room.MovableDoor movableDoor = room.getMovableDoor(DOOR_STATUS.OPEN);
/* 访问非静态内部类的成员需要使用非静态内部类的实例 */
System.out.println(movableDoor.status.toString());
movableDoor.dispaly();
Room.MovableDoor movableDoor1 = room.new MovableDoor(DOOR_STATUS.CLOSED);
movableDoor1.dispaly();
}
}
- 成员内部类
public class Supermarket {
private String name;
private Supermarket(String name){
this.name = name;
}
private Shelf getShelfInstance(int code){
return new Shelf(code);
}
private void displayOut(){
System.out.print("超市名 : "+ name);
}
/*3 .成员内部类中不能存在任何static的变量和方法*/
private class Shelf{
private int code;
private Shelf(int code){
this.code = code;
}
private int getCode() {
return code;
}
private void setCode(int code) {
this.code = code;
}
private void display(){
/* 1 .成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法,尽管是private的*/
displayOut();
System.out.print(" | 货架号 : " + code);
System.out.println();
}
}
public static void main(String[] args) {
/*4 .成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。*/
Supermarket supermarket = new Supermarket("苏果超市");
Shelf shelf1 = supermarket.getShelfInstance(1);
Shelf shelf2 = supermarket.getShelfInstance(2);
Shelf shelf3 = supermarket.new Shelf(2);
/*2 .但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。*/
shelf1.display();
System.out.println("-----------------------------------------------");
shelf2.display();
}
}
- 匿名内部类
public class Zoo {
public Animal getAnimal(String myname){
/*这个内部类是没有名字的*/
return new Animal(myname) {
@Override
public void livingHouse() {
System.out.println(getName() + "来了");
}
};
}
public Manager getManager(String manager){
return new Manager() {
String nameOfManager = manager;
@Override
public void manage() {
System.out.println(nameOfManager + "是管理者");
}
};
}
public static void main(String[] args) {
Zoo zoo = new Zoo();
Animal elephent = zoo.getAnimal("大象");
elephent.livingHouse();
Manager manager = zoo.getManager("我");
manager.manage();
}
}
abstract class Animal{
private String name;
Animal(String name){
this.name = name;
}
String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract void livingHouse();
}
interface Manager{
void manage();
}
- 其他测试（内部private）
public class TestOuterClass {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public class Innerclass{
public Innerclass(){
/*我们可以看到内部了InnerClass可以对外围类OuterClass的属性进行无缝的访问，尽管它是private修饰的。*/
/*这是因为当我们在创建某个外围类的内部类对象时，此时内部类对象必定会捕获一个指向那个外围类对象的引用，只要我们在访问外围类的成员时，就会用这个引用来选择外围类的成员。*/
name = "Innerclass";
age = 11;
}
public void display(){
System.out.println("Innerclass : name：" + getName() +" ; age：" + getAge());
}
}
public class Innerclass1{
public Innerclass1(){
name = "Innerclass1";
age = 12;
}
public void display(){
System.out.println("Innerclass1 : name：" + getName() +" ; age：" + getAge());
}
}
public static void main(String[] args) {
TestOuterClass testOuterClass = new TestOuterClass();
/*如果我们需要创建某个内部类对象，必须要利用外部类的对象通过.new来创建内部类*/
TestOuterClass.Innerclass innerclass = testOuterClass.new Innerclass();
innerclass.display();
TestOuterClass.Innerclass1 innerclass1 = testOuterClass.new Innerclass1();
innerclass1.display();
/*内部类是个编译时的概念，一旦编译成功后，它就与外围类属于两个完全不同的类（当然他们之间还是有联系的）*/
/*对于一个名为OuterClass的外围类和一个名为InnerClass的内部类，在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class。*/
}
}
