面向对象-内部类与枚举
内部类
内部类:定义在类当中的一个类
内部类作用:
1.增强封装,把内部类隐藏在外部类当中,不允许其他类访问这个内部类
2.增加了代码的维护性
3.内部类可以直接访问外部类当中成员
提示:外部类的修饰符只能有两个 public 和 默认 其他什么都不加
内部类的修饰符可以任意使用
类当中的成员:
字段
方法
内部类
外部类
class Out{
内部类
class In{
}
}
内部类划分
内部类可以分为四种
1.实例化内部类:直接定义在类中的一个类,在类前面没有定义任何一个修饰符
2.静态内部类:在内部类前面加上一个static
3.局部内部类:定义在方法的内部类
4.匿名内部类:属于局部内部类的一种特殊情况
外部类的修饰符只能有两个,public 或者是 默认修饰符
内部类可以使用很多个修饰符
实例内部类
实例内部类:直接定义在类当中的一个类,在类前面没有任何一个修饰符
属于对象的内部类,不属于类的,不使用static修饰的内部类
想要使用内部类,必须得要先创建内部类
创建实例内部类
创建内部类对象当中,会有一个外部类的引用
Outter Outter = new Outter();
Outter.Inner in = Outter.new Inner();
在内部类当中可以访问外部类当中的成员
在内部类当中,不能有静态成员(实例内部类属于对象)
外部类不能直接访问内部类当中的成员
变量的访问:就近原则
class Outter{
String name="outtername";
class Inner{
String name = "innername";
void test() {
String name = "testname";
System.out.println(name);//testname
System.out.println(this.name);//innername
System.out.println(Outter.this.name);//outtername
}
}
}
public class InnerClass {
public static void main(String[] args) {
Outter Outter = new Outter();
//创建实例化内部类
//创建内部类对象那个当中,会有一个外部类的引用
Outter.Inner in = Outter.new Inner();
in.test();
}
}
创建内部类对戏那个当中,会有一个外部类的引用
静态内部类
静态内部类:
属于类的内部类
在内部类前面加上static
1.静态内部类是不需要创建外部类对象的
创建内部类
Outter.Inner in = new Outter.Inner();
2.在静态内部类当中,是没有外部类引用的(外部类不用创建对象)
3.静态内部类,是可以访问外部类的静态成员
静态内部类,是不可以访问外部类的非静态成员
如果想访问外部非静态成员可以创建外部类对象
class Outter {
static String name = "zs";
int age = 10;
static class Inner {
static String color = "black";
void test() {
//System.out.println(name);静态成员可以之计访问
//System.out.println(age);会报错
System.out.println(new Outter().age);//10
}
}
}
4.访问静态内部类当中的静态成员
System.out.println(Outter.Inner.color);
5.静态内部类当中可以定义静态成员,也可以定义非静态成员
局部内部类
局部内部类:定义在方法的内部类
1.不能使用一些修饰符 public private protected
2.局部内部类只能在定义的方法当中使用
3.局部内部类不能包含静态变量 static
4.局部内部类当中可以包含局部变量,使用局部变量的本质是final 常量
final存在于方法区当中
对当中一个对象没有人引用,它并不是直接就销毁
匿名内部类
匿名内部类:就是一个没有名字的局部内部类(方法当中的)
匿名内部类是没有构造器的(因为没名字)
匿名内部类只使用一次的时候,才使用匿名内部类
new 父类的构造器 或 接口(){
内部写的代码(在new的时候就会自动执行)
}
bpluginIn(new Iusb() {
public void swapDate() {
System.out.println("打印工作");
}
})
匿名内部类必须得要有父类才行,或者是实现了接口
package 模拟枚举;
enum WeekDay{
MONDAY,TUESDAY,WENDSDAY,THURDAY,FRIDAY,SATURDAY,SUNDAY;
}使用枚举之后与下面注释了的代码相同作用
//定义一个星期几的常量类
/*class WeekDay {
private WeekDay();
public static final WeekDay MONDAY = new WeekDay();
public static final WeekDay TUESDAY = new WeekDay();
public static final WeekDay WENDESDAY = new WeekDay();
public static final WeekDay THURSDAY = new WeekDay();
public static final WeekDay FRIDAY = new WeekDay();
public static final WeekDay SATURDAY = new WeekDay();
public static final WeekDay SUNDAY = new WeekDay();
}*/
class Student {
private WeekDay restDay;
public WeekDay getRestDay() {
return restDay;
}
public void setRestDay(WeekDay restDay) {
this.restDay = restDay;
}
}
public class Test {
public static void main(String[] args) {
Student stu = new Student();
stu.setRestDay(WeekDay.SATURDAY);
WeekDay res = stu.getRestDay();
if(res==WeekDay.SATURDAY||res==WeekDay.SUNDAY) {
System.out.println("你放假了");
}else {
System.out.println("别想了,继续上课");
}
}
}
枚举的定义
枚举:表示一个事件的固定状态
java 枚举:是一个特殊的类,多个常量对象的集合
[修饰符] enum 枚举的名称{
常量1, 常量2, 常量3, 常量4.....
}
不能直接创建对象
在编译的时候会把构造器私有化,就不能创建对象了(在反编译工具中看到的)
枚举还可以用在switch当中,其实是传入的是本质还是int类型,返回的是ordinal,传入的值在当前的下标
enum Sex {
MALE, FEMALE;
}
public class Test1 {
public static void main(String[] args) {
System.out.println(Sex.FEMALE);
System.out.println(Sex.FEMALE.name());
System.out.println(Sex.FEMALE.ordinal());
System.out.println(Sex.MALE.name());
switch (Sex.MALE) {
case FEMALE:
break;
case MALE:
break;
}
Sex s = Sex.valueOf("MALE");转换成枚举类型 字符串必须得是枚举当中的一个值
System.out.println(s);
// 获取枚举当中的所有元素,放到一个数组当中
Sex[] alllres = Sex.values();
for (Sex sex : alllres) {
System.out.println(sex);
}
System.out.println(alllres[1]);
}
}
