内部类 枚举（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 接口{

}