1.内部类
* 内部类：在类的内部定义一个类，可以看做类的成员
* 类的成员：字段、方法、类
* 内部类类型：
* 1.实例内部类
* 2.静态内部类
* 3.局部内部类
* 4.匿名内部类
1.1 实例内部类
* 实例内部类
* 位置：类中，方法外
* 修饰符：public、private、protected、默认
* 不能有：static
* 类中定义的成员
* 不能使用static进行修饰
* 访问权限修饰符：都可以
* 内部类访问外部类的成员
* 在内部类中可以直接访问外部类的成员（实例和静态）
package day13.innerclass;
public class OutDemo1 {
//外部类的属性
String name;
int age;
//外部类的方法
public void method1() {
System.out.println("外部类");
}
//定义一个实例内部类
class Inner{
//定义内部成员
String name;
//static int num;//不能使用static进行修饰
public void printmsg() {
System.out.println("实例类的内部方法:"+name);
}
public void printOutMsg() {
//如果外部类成员和内部类成员一致，默认访问的是内部类成员
//如果是访问外部类成员
System.out.println(OutDemo1.this.name);
//调用外部类的method1方法
OutDemo1.this.method1();
//通过内部类给外部类成员赋值
OutDemo1.this.age=21;
}
public void method1() {
System.out.println("内部类");
}
//构造方法
public Inner() {
// TODO 自动生成的构造函数存根
System.out.println("内部类默认构造方法");
}
}
}
package day13.innerclass;
import day13.innerclass.OutDemo1.Inner;
public class TestDemo {
public static void main(String[] args) {
//使用内部类
//初始化外部类
OutDemo1 out=new OutDemo1();
out.name="浪子一秋";
//初始化一个内部类
Inner inner=out.new Inner();
//给内部类赋值
inner.name="尊";
//访问内部类的方法
inner.printmsg();
inner.printOutMsg();
inner.method1();
//直接初始化一个内部类，但是外部类不能直接访问
OutDemo1.Inner in=new OutDemo1().new Inner();
in.printOutMsg();
}
}
1.2静态内部类
* 静态内部类
* 位置：类中，方法外
* 修饰符:只能static abstract final public private protected 默认
* 成员：静态，非静态
package day13.innerclass;
public class OutDemo2 {
String name;
static int number;
public void method1() {
System.out.println("外部类实例方法");
}
public static void method2() {
System.out.println("外部类静态方法");
}
static class Inner1{
String name;
static int age;
public Inner1() {
// TODO 自动生成的构造函数存根
System.out.println("内部类默认构造方法");
}
public void method1() {
System.out.println("内部类实例成员");
//静态内部类实例成员可以访问外部类的静态成员
number=100;
name="尊";//代表内部类
//OutDemo2.this.name="11";//不允许访问外部类的实例成员
}
public static void method2() {
//只能访问外部类的静态成员
System.out.println("内部类静态成员");
}
}
public static void main(String[] args) {
//初始化一个静态内部类,没有初始化外部类
OutDemo2.Inner1 inner1=new OutDemo2.Inner1();
//访问内部类成员,可以访问使用成员
inner1.method1();//内部类实例成员
inner1.method2();//内部类静态成员
//直接访问内部类的静态成员,通过类名访问
OutDemo2.Inner1.age=21;
OutDemo2.Inner1.method2();
//内部类可以访问外部类的静态成员
}
}
1.3局部内部类
* 局部内部类
* 位置：方法中
* 成员：必须是实例成员
* 只能在声明方法中使用
package day13.innerclass;
public class OutDemo3 {
//属性
String name;
int sex;
public void methord1() {
System.out.println("外部类的实例方法");
}
public void method2() {
int num=10;
class Inner2{
String name;
int age;
public void method3() {
//局部内部类可以访问外部类的所有成员
System.out.println(sex);
//访问外部类、方法内的局部变量,局部变量必须加上final修饰符，jdk1.8之后不需要加
System.out.println(num);
System.out.println("局部内部类的实例方法");
}
/*public static void method4() {
}*/
}
//初始化一个内部类对象
Inner2 in=new Inner2();
in.name="尊";
in.age=21;
in.method3();
}
public static void main(String[] args) {
//初始化一个外部类对象
OutDemo3 demo3=new OutDemo3();
demo3.method2();
}
}
1.4匿名内部类
* 匿名内部类：当前这个类是没有名字的
* 定义的位置：方法内
package day13.innerclass;
//声明一个接口
interface MyInterface{
public void sendMsg(String msg);
}
public class OutDemo4 {
public static void method3(MyInterface face) {
face.sendMsg("你好啊");
}
public static void main(String[] args) {
//定义了一个匿名的类，类的名字不知道，这个类肯定实现了接口
MyInterface face=new MyInterface() {
//属性
//方法
void method2(){
System.out.println("Hello");
}
@Override
public void sendMsg(String msg) {
// TODO 自动生成的方法存根
System.out.println(msg);
}
};
//多态
method3(face);
}
}
2 枚举
* 默认继承java.lang.enum这个类
* 使用过程中，只用神秘常量
* 多个常量之间用逗号隔开
* 常量必须放在第一行
* 常量都是引用数据类型 ,都是当前枚举的对象
package day13.Test;
//定义一个枚举类
enum Weekday3{
MON,TUES,WEDES,THURS,FRI,SATUR,SUN;
//public static final Weekday3 MON=new Weekday3();等价于MON
//枚举类内部，可以声明字段、方法、构造方法、内部类，必须放在常量之后
int age;
public void method1() {
System.out.println("写代码");
}
//构造方法必须私有化
private Weekday3() {}
}
public class Employee3 {
//属性
private Weekday3 restday;
public Weekday3 getRestday() {
return restday;
}
public void setRestday(Weekday3 restday) {
this.restday = restday;
}
//判断是否是休息日
public void restDay() {
switch (this.restday) {
case MON:
case TUES:
case WEDES:
case THURS:
case FRI:
case SATUR:
System.out.println("天天写代码");
break;
case SUN:
System.out.println("休息一天");
break;
}
}
public static void main(String[] args) {
//初始化对象
Employee3 em3=new Employee3();
//数组属性的值 枚举
em3.setRestday(Weekday3.FRI);
//判断
em3.restDay();
//获取枚举对象的名称
String name=Weekday3.SUN.name();
System.out.println(name);
name=Weekday3.FRI.toString();
System.out.println(name);
//获取枚举对象 常量的序列号 从0开始
int index=Weekday3.THURS.ordinal();
System.out.println(index);
//获取所有的枚举常量，返回一个数组对象
Weekday3[]arr=Weekday3.values();
for(Weekday3 weekday3:arr){
System.out.println(weekday3);
}
//将string类型转换成枚举常量，要去string名称和枚举常量名称一致
Weekday3 day=Weekday3.valueOf("SUN");
System.out.println(day);
System.out.println(day.ordinal());
}
}
3.知识框架
