内部类 枚举（enum）基本属性和使用详解

☆☆☆内部类和枚举的使用解析 枚举创建于调用

一、内部类

概念：

一个类中又定义了一个完整的类结构。

被包含的类 称为 内部类
类体中包含其他类的类 称为 外部类

其他的类 称为 外部其他类
           

1、分类

(一)成员内部类

    特点：
          1.可以加访问修饰符

          2.作用范围比较大，外部类和外部其他类都能访问到
    分类
        <1>普通成员内部类

            1.外部类的成员和内部类的成员同名，默认遵循就近原则，
              如果想访问外部类的成员，可以通过Outer.this.成员访问

            2.不允许有静态成员的

            3.互访原则：
                  外部类访问内部类，通过创建对象，使用对象名访问

                  外部其他类访问内部类，通过创建对象，使用对象名访问
        <2>静态内部类

            1.外部类的成员和内部类的成员同名，默认遵循就 近原则，
              如果想访问外部类的成员，可以通过Outer.成员访问

            2.里面不能直接访问外部类的非静态成员

            3.互访原则:
                外部类访问内部类，通过创建对象，使用对象名访问
                外部其他类访问内部类，通过创建对象，使用对象名访问

（二）局部内部类
    特点：
        1.不可以加访问修饰符

        2.作用范围比较小，外部类其他方法和外部其他类不能访问

        3.不能访问 外部类的非 final的局部变量
    分类
        局部内部类
            有名称，可以多次使用

        匿名内部类
            没有名称，只能使用一次

            作为类的子类或 接口的实现类

            应用场景
                1.充当抽象类或接口 类型 的实参时
                2.开启线程
                3.设置监听器
           

2、格式如下：

class Outer{//外部类

    class Inner{//内部类

    }
}
class Other{//外部其他类

}
           

3、好处

内部类 可以直接访问外部类中的所有成员（包含私有的！！）

4按定义位置不同分为以下几类：

成员内部类：
          普通成员内部类（没有static修饰）
          静态内部类（有static修饰）

局部内部类：
          局部内部类（有类名）
          匿名内部类（没类名）
           

5代码实例如下：

(一)、成员内部类的特点

1.可以加 任意访问修饰符

2.外部类的成员和内部类成员重名时，默认遵循就近原则，

如果想访问外部类成员，需要使用 ：外部类名.this.成员名 访问

<2>.互访原则

1》 内部类如何访问外部类的成员？

直接访问

2》外部类如何访问内部类的成员?

通过内部类的对象名访问

语法：Inner inner =new Inner();

访问 inner.成员

3》外部其他类如何访问内部类的成员？

语法： Outer.Inner inner = new Outer().new Inner();
    inner.method();
           

exa:

public class TestInnerDemo1 {
public static void main(String[] args) {
    OuterOther oo = new OuterOther();
    oo.other1();
}
}
           

//外部其他类

class OuterOther{
public void other1(){
    Outer.Inner inner = new Outer().new Inner();
    inner.method();

//System.out.println(inner.height);

}
}
class Outer{

protected String name="john";
int age=10;


public void test1(){

    Inner i =new Inner();

    System.out.println(i.height);
}

public class Inner{

    String name="helloworld";

    double height=100;
    public void method(){

        //如何访问 外部类的成员？
        System.out.println(name);//访问的是  helloworld

        //如何外部类的成员和内部类的成员名称一样，如何访问外部类的成员
        System.out.println(Outer.this.name);//访问的是 john

    }
}
} 
           

(二)是静态内部类的特点

1.可以加访问修饰符
2.只能访问 外部类的静态成员

3.外部类和内部类的成员名称一样， 默认访问的是内部类成员，遵循就近原则。 
  如果想访问外部类的成员，直接通过 ：类名.成员
           

<2>.互访原则

1 内部类如何访问外部类成员？

只能直接访问外部类的静态成员
           

2》外部类如何访问内部类成员？

Inner inner  = new Inner();
System.out.println(inner.height);
           

3》外部其他类如何访问内部类成员？

Outer .Inner inner = new  Outer.Inner();

    System.out.println(inner.height);
           

exa:

public class TestInnerDemo2 {
public static void main(String[] args) {
}
}
//外部其他类
class OuterOther{

public void other1(){

    //创建对象 ，通过对象访问

    Outer .Inner inner = new  Outer.Inner();

    System.out.println(inner.height);
}
}
//外部类
class Outer{

protected String name="john";
static int age=10;


public static  void test1(){
    Inner i = new Inner();
    System.out.println(i.height);
}
//内部类
protected static class Inner{

    int age=100;
    String name="helloworld";

    double height=100;
    public void method(){

        System.out.println(Outer.age);

        test1();
    }
}
           

}

(三)局部内部类

1.局部内部类不可以加修饰符

2.局部内部类可以直接访问外部类的成员，如果访问外部类的局部  

  变量，此局部变量必须是final修饰的
           

3.互访原则

1》内部类如何访问外部类

直接访问

2》

外部类如何访问内部类只能在定义此内部类的方法内访问，而且遵循前向引用

不能内置 其他外部类的地方访问
           

3》外部其他类如何访问内部类

无法访问

exa:

public class TestInnerDemo3 {

}

//外部类

class Outer{

String name=”john”;

public void method2(){
}
public void method(){

    final int count=10;//局部变量

    //局部内部类
     class Inner{

         public void test1(){
             System.out.println(count);
         }
    }
     Inner i = new Inner();
}
           

}

二、枚举

（1）如何自定义枚举类 √

实现步骤：

1、构造方法私有化 √

2、本类创建好固定的几个对象 √

修饰符 ：public static final

class Season{

    private String name;//季节名
    private String desc;//季节描述


    //构造方法私有化
    private Season(String name,String desc){
        this.name=name;
        this.desc=desc;

    }

    public static final Season SPRING=new Season("春天","春暖花开的季节");
    public static final Season SUMMER=new Season("夏天","生如夏花");
    public static final Season AUTUMN=new Season("秋天","花儿都谢了");
    public static final Season WINTER=new Season("冬天","花儿都冻坏了！！");
    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }


    @Override
    public String toString() {
        return name+"\t"+desc;
    }
}
           

（2）如何使用enum定义枚举类 ★

enum Season2{
    SPRING("春天","春暖花开的季节"),
    SUMMER("夏天","生如夏花"),
    AUTUMN("秋天","花儿都谢了"),
    WINTER("冬天","花儿都冻坏了！！");
    private Season2(String name,String desc){
        this.name=name;
        this.desc=desc;
    }

    private String name;
    private String desc;
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }

    public void show(){
        System.out.println("这是一个季节");
    }
    @Override
    public String toString() {
        return name+"\t"+desc;
    }

}
           

（3）枚举类的主要方法

//方法一：valueOf ,返回指定对象名  对应对象

    Season3 s = Season3.valueOf("SPRING");

    System.out.println(s);

    //方法二： toString ,返回该枚举对象的字符串形式

    Season3  s1 =Season3.SPRING;
    System.out.println(s1);


    //方法三：ordinal ,返回枚举对象在类中定义的索引

    int ordinal = Season3.WINTER.ordinal();
    System.out.println(ordinal);


    //方法四：values ,返回该枚举类中所有的对象

    Season3[] values = Season3.values();
    for (int i = 0; i < values.length; i++) {
        System.out.println(values[i]);
    }
           

（4）实现接口的枚举类 √

enum A implements 接口{

}