一个类TestOuter的内部的类SubTest叫内部类。
内部类:SubTest ,外部类:TestOuter。
内部类:成员内部类 (静态的,非静态的) 和 局部内部类(位置:方法内,块内,构造器内)
1、成员内部类
代码示例:
package Package8_face_the_object.test_inner_class;
/*
内部类的使用介绍:
首先:
1.类的组成:属性,方法,构造器,代码块(普通块,静态块,构造块,同步块),内部类
2.一个类TestOuter的内部的类SubTest叫内部类, 内部类 :SubTest 外部类:TestOuter
3.内部类:成员内部类 (静态的,非静态的) 和 局部内部类(位置:方法内,块内,构造器内)
4.成员内部类:(本代码示例!!!)
* 里面属性,方法,构造器等(里面甚至可以再加一个内部类,但一般不推荐/常用)
* 修饰符:private,default,protect,public,final,abstract
*/
public class TestOuter {
//(非静态)成员内部类
public class D{
int age = 20;
String name;
public void method(){
//5.内部类可以访问外部类的内容
/*System.out.println(age);
a();*/
int age = 30;
//8.内部类和外部类属性重名的时候,如何进行调用
System.out.println(age);//30 -- 就近原则
System.out.println(this.age); // 20
System.out.println(TestOuter.this.age); // 10
}
}
//静态成员内部类
static class E{
public void method(){
//6.静态内部类中只能访问外部类中被static修饰的内容
/*System.out.println(age);
a();*/
}
}
//下面就属于外部类的内容(内部类之外的)
//属性
int age = 10;
//方法
public void a(){
System.out.println("这是a()方法!");
//普通块
//普通块可以写在方法里面
{
System.out.println("这是一个普通块!");
class B{ //局部内部类——2)块内
}
}
class A{ //局部内部类——1)方法内
}
//7.外部类想要访问内部类的东西,需要创建内部类的对象然后进行调用
//System.out.println(name); //不能直接访问
D d = new D();
System.out.println(d.name);
d.method();
}
//静态块 —— 最优先被加载
static{
System.out.println("这是一个静态块!");
}
//构造块 —— 构造块和构造器,构造块先执行
{
System.out.println("这是一个构造块!");
}
//构造器
public TestOuter() { //空构造器
class C{ //局部内部类——3)构造器内
}
}
public TestOuter(int age) { //有参构造器
this.age = age;
}
}
//测试类
class Demo{
public static void main(String[] args) {
//创建外部类的对象
TestOuter to = new TestOuter();
//测试一下method()方法的输出
//调用a()方法就行了,因为a()方法里调用了method()方法
to.a();
//创建内部类的对象:
//静态成员内部类E --创建对象
TestOuter.E e = new TestOuter.E(); //因为是静态的,(外部类)直接调用即可
//(非静态)成员内部类D --创建对象
//TestOuter.D d = new TestOuter.D(); //非静态的不能这么调
//因为 非静态)成员内部类D 也属于类的成员
//所以,得先有一个外部类(的对象),并通过这个创建的外部类对象去调用!!!
TestOuter to2 = new TestOuter();
TestOuter.D d = to2.new D();
}
}
2、局部内部类
涉及到 —— 匿名内部类 的概念。
(即,这个类没有名字,直接通过接口来创建这个类的对象(然后可以用接口去接这个对象) 相当于 —— 接口等于实现类的对象)
代码示例:
package Package8_face_the_object.test_inner_class;
/*
内部类:成员内部类 (静态的,非静态的) 和 局部内部类(位置:方法内,块内,构造器内)
局部内部类:(本代码示例!!!)
(匿名内部类!!!)
*/
public class TestOuter2 {
//1.在局部内部类中访问到的变量必须是被final修饰的
public void method(){
//int num = 10;
final int num = 10;
//局部内部类 —— 方法内
class A{
public void a(){
//num =20; // 没有用final修饰,但实际上就是final属性,这也是不能更改其值的原因
System.out.println(num); //这里,现在num前面没有用final修饰,
// 可以访问到,但是在JDK1.8之前不行
//即,要想在a()方法中访问属性num,那么该属性必须是被final修饰的
}
}
}
//2.如果类B在整个项目中只使用一次,那么就没有必要单独创建一个B类,使用内部类就可以了
//(对应:为什么不把B类定义在外部)
public Comparable method2(){ //把void返回值类型改为Comparable接口,
//那么返回值的类型必须是具体实现类的对象
// 即,如果把接口作为方法的返回值类型,那么返回值的类型必须是具体实现类的对象
//这里,具体实现类为B类 (这也属于一个小的多态的应用)
class B implements Comparable{
@Override
public int compareTo(Object o) {
return 100;
}
}
return new B();
}
//2的同等效果,进行简化(都不用创建B类了)
//3、匿名内部类(即,这个类没有名字,直接通过接口来创建这个类的对象(然后可以用接口去接这个对象))
//相当于 —— 接口等于实现类的对象
public Comparable method3(){
return new Comparable(){ //接口不能创建对象
@Override //会提示,让对方法进行重写
public int compareTo(Object o) {
return 200;
}
}; //return后面(到分号之前)都是一个对象
}
//3的等效,
//既然return后面都是一个对象,那么我们可以用一个 Comparable com 去接收
public void test(){
Comparable com= new Comparable(){
@Override
public int compareTo(Object o) {
return 150;
}
};
//com是一个对象,则里面的compareTo()方法可以调用
System.out.println(com.compareTo("abc"));
}
}