【内部类】

Kovyi_Mar25

已于 2023-04-11 15:22:24 修改

阅读量91

点赞数

分类专栏： java基础文章标签： java

于 2023-04-10 22:03:03 首次发布

本文链接：https://blog.csdn.net/wrrare/article/details/130069196

版权

java基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

内部类：定义在一个类类体当中的类，被称作内部类
为什么要使用内部类？
1. 内部类是共享数据最简单的方式之一
2. 内部类还能体现类和类之间的专属关系
3. 内部类编译之后同样会生成.class文件，其命名规则为：外部类名字$内部类名字.class
内部类的分类：成员内部类、静态内部类、局部内部类、匿名内部类

成员内部类：能够共享外部类的所有[静态+非静态]成员[属性+方法]

如何理解其与外部类的关系：蛔虫和牛的关系
如何创建其对象：Outer.Inner in = new Outer().new Inner();

public class TestMemberInner{
	public static void main(String[] args){
        Outer.Inner in1 = new Outer().new Inner();
        in1.test();
        Outer out = new Outer();
        Outer.Inner in2 = out.new Inner();
        in2.test();
    }
}
class Outer{
    int a = 3;//成员变量 = 实例变量 =属性
    static int b = 4;//静态变量
    
    class Inner{
        int x = 5;
        public void test(){//成员内部类
            System.out.println(a);
            System.out.println(b);
            System.out.println(x);
        }
    }
}

静态内部类：只能共享外部的静态成员[属性+方法]

如何理解其与外部类的关系：房客和房东的关系或者寄居蟹和蛤蜊壳的关系
如何创建其对象：Outer.Inner in = new Outer.Inner();
使用静态内部类，我们能够共享外部类的静态成员
静态成员还需要内部类去共享吗？静态内部类的存在并不是为了共享数据的，而是为了体现类与类的专属性关系...

public class TestStaticInner{
	public static void main(String[] args){
        Outer.Inner in1 = new Outer.Inner();
        in1.test();
    }
}
class Outer{
    int a = 3;
    static int b = 4;

    static class Inner{//静态内部类
        int x = 5;
        static int y = 5;
    
        public void test(){
            //System.out.println(a); 无法从静态上下文访问非静态变量
            System.out.println(b);
            System.out.println(x);//取决于test是否是非静态的
            System.out.println(y);
        }
    }
}

局部内部类：能够共享外部类的什么？

如果定义在静态方法中：只能共享外部类静态成员
如果定义在非静态方法中：能够共享外部类所有成员
另外，由于局部内部类定义在方法体中，所以还能共享访问所在的外部类方法中的局部变量。只是jdk8.0之前必须加final修饰，从jdk8.0开始可以不加，但是默认就是final
如何理解其与外部类的关系：老师和学生的关系(老师仅限在某个时间段内管理学生)
如何创建其对象：Inner in = new Inner()；注意：有位置限定(定义完成之后，所在方法结束之前)

public class TestLocalInner{
	public static void main(String[] args){

	}
}
class Outer{
    int a = 3;
    static int b = 4;
    
    public void gogo(int c){
        int d = 7;

        class Inner{//局部内部类
            int x = 9;  
            
            public void test(){
                System.out.println(a);//取决于test是否是非静态的
                System.out.println(b);
                System.out.println(c);//取决于jdk版本
                System.out.println(d);//取决于jdk版本
                System.out.println(x);
            }
        }
        //Inner
        Inner in = new Inner();
        in.test();
    }
}

匿名内部类：比如某些场景下，我们自己的名字无关紧要，反而长辈的名字才重要

语法--继承父类：new 父类(给父类构造方法传参){ 完成方法覆盖; }
语法--实现接口：new 接口(){ 完成抽象方法的具体实现 }
能够共享外部类的哪些内容？完全取决于它的位置，可能等价于上述三种的某一种

import java.util.*;
public class TestAnonyInner1{
	public static void main(String[] args){
        //一个实现了Comparetor接口的，但是没有名字的 类的对象
        Set<Integer> set = new TreeSet<>(new Comparator<Integer>(){
            @Override
            public int compare(Integer i1,Integer i2){
                return i2.compareTo(i1);
            }
        });
        Collections.addAll(set,55,33,44,11,22);
        //降序排序
        System.out.println(set);
    }
}
public class TestAnonyInner2{
	public static void main(String[] args){
        //使用标准语法创建一个学生对象，并调用方法
        Student stu = new Student();
        stu.eat();
        //请使用匿名内部类语法创建一个老师对象 并调用方法
        Person p = new Person("孔子"){
            @Override
            public void eat(){
                System.out.println("老师吃包子");
            }
        };
        p.eat();
    }
}
abstract class Person{
    String name;
    public Person(String name){
        this.name = name;
    }
    public abstract void eat();
}
class Student extends Person{
    public Student(){
        super("子贡");
    }
    @Override
    public void eat(){
        System.out.println("学生吃饺子");
    }
}
public class TestAnonyInnerPlus{
	public static void main(String[] args){
        //降序排序
        Set<Integer> set = new TreeSet<>((a,b) -> b.compareTo(a));
        Collections.addAll(set,55,33,44,11,22);
        System.out.println(set);
    }
}

java中如何完成数据共享：
1. 使用静态变量完成数据共享
2. 使用参数传递完成数据共享(优先选Setter即set方法)
3. 使用内部类完成数据共享

//1.使用静态变量完成数据共享
public class TestShareData1{
	public static void main(String[] args){
        吕布 lxb = new 吕布();
        董卓 daz = new 董卓();
        lxb.test();
        daz.test();
    }
}
class 广寒宫{
    static Object 貂蝉 = new Object();
}
class 吕布{
    public void test(){
        System.out.println(广寒宫.貂蝉);
    }
}
class 董卓{
    public void test(){
        System.out.println(广寒宫.貂蝉);
    }
}

//2.使用参数传递完成数据共享
public class TestShareData2{
	public static void main(String[] args){
		Object 貂蝉 = new Object();
		吕布 lxb = new 吕布(貂蝉);
		董卓 ddz = new 董卓(貂蝉);
		lxb.test();
		ddz.test();

	}
}

class 吕布{
	Object 夫人;
	public 吕布(Object 夫人){
		this.夫人 = 夫人;
	}
	public void test(){
		System.out.println(夫人);
	}
}
class 董卓{
	Object 夫人;
	public 董卓(Object 夫人){
		this.夫人 = 夫人;
	}

	public void test(){
		System.out.println(夫人);
	}
}

//3.使用内部类完成数据共享
public class Test{
	public static void main(String[] args){
		广寒宫 g = new 广寒宫();
        广寒宫.吕布 lxb = g.new 吕布();
        广寒宫.董卓 ddz = g.new 董卓();
		lxb.test();
		ddz.test();
	}
}
class 广寒宫{
	Object 貂蝉 = new Object();
	class 吕布{
		public void test(){
			System.out.println(貂蝉);
		}
	}
	class 董卓{
		public void test(){
			System.out.println(貂蝉);
		}
	}
}

/**        
    一个凄美的爱情故事：
	    主角是一对小情侣
	    一个小男孩和一个小女孩
	    他们两个约会去看电影 但是钱不太多
	    于是 买了两张电影票之后 只够买一杯大可乐
	    他们找服务员要了两根吸管 共享同一杯大可乐

        使用数据共享的三种方式实现,参数传递的用Setter
*/
public class shareDate1{
    public static void main(String[] args){
        Boy b = new Boy();
        Girl g = new Girl();
        b.test();
        g.test();
    }
}
class Cinema{
    /**
        static修饰的变量叫做静态变量
        不是每一个对象都有一份，而是整个类型共享一份的
        不依赖任何一个对象而存在
        使用静态变量可以使用类名.变量名直接访问
    */
    static Object cola = new Object();
}
class Boy{
    public void test(){
        System.out.println(Cinema.cola);
    }
    
}
class Girl{
    public void test(){
        System.out.println(Cinema.cola);
    }
}

public class shareDate2{
    public static void main(String[] args){
	    Object cola = new Object();
       
        Boy b = new Boy();
       	b.setWdyl(cola);
        Girl g = new Girl();
        g.setTdyl(cola);

        b.test();
        g.test();
    }
}

class Boy{
    Object wdyl;
    public void setWdyl(Object wdyl){
        this.wdyl = wdyl;
    }
    public void test(){
        System.out.println(wdyl);
    }

}
class Girl{
    Object tdyl;
    public void setTdyl(Object tdyl){
        this.tdyl = tdyl;
    }
    public void test(){
        System.out.println(tdyl);
    }
}


public class shareDate3{
    public static void main(String[] args){
		Cinema c = new Cinema();
		Cinema.Boy xl = c.new Boy();
		Cinema.Girl xh = c.new Girl();
		xl.test();
		xh.test();
    }
}

class Cinema{
	Object cola = new Object();

	class Boy{
	    public void test(){
	        System.out.println(cola);
	    }

	}

	class Girl{
	    public void test(){
	        System.out.println(cola);
	    }
	}

}

public class TestPlus01{
	public static void main(String[] args){
		A.C cc = new A().new C();
		cc.test();
	}
}
class D{
	int i = 7;
}
class A{
	int i = 3;

	class C extends D{
		int i = 9;

		public void test(){
			System.out.println(i);//?
			System.out.println(this.i);
			System.out.println(C.this.i);

			System.out.println(A.this.i);

			System.out.println(super.i);
			System.out.println(C.super.i);
		}
	}
}

public class TestPlus02{
	public static void main(String[] args){
		Student stu = new Student();
		Teacher tea = new Teacher();
		tea.setMyStudent(stu);
		stu.setMyTeacher(tea);

	}
}
class Student{
	Teacher myTeacher;
	public void setMyTeacher(Teacher myTeacher){
		this.myTeacher = myTeacher;
	}
}
class Teacher{
	Student myStudent;
	public void setMyStudent(Student myStudent){
		this.myStudent = myStudent;
	}
}