内部类
一般情况下,类和类之间是相互独立的,内部类的意思是打破这种独立,让一个类成为另外一个类的内部信息,和成员变量,成员方法同等级别。
1、非静态内部类
package com.ycz.test;
/**
* @Description:
* @Author: Alex
* @Date 2022-07-06-15:53
* @Version: V1.0
**/
public class OuterClass {
private String outerName;
public void display(){
System.out.println("OtherClass display");
System.out.println(outerName);
}
public class InnerClass{
private String innerName;
public void display(){
System.out.println("innerClass");
System.out.println(innerName);
}
public InnerClass(){
innerName = "inner Class";
}
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.display();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.display();
}
}
结果:
非静态内部类的使用就是将内部类当做外部类的一个成员变量/成员方法来使用,所以必须依赖于外部类的对象才能调用,用法和成员变量/成员方法是一致的。
为什么使用内部类
采用内部类这种技术,可以隐藏细节和内部结构,封装性更好,让程序的结构更加合理
方法内部类
package com.ycz.test;
/**
* @Description:
* @Author: Alex
* @Date 2022-07-06-16:08
* @Version: V1.0
**/
public class OuterClass2 {
private String outerName;
public void display(){
class InnerClass2{
public void display(){
System.out.println("method inner class");
}
}
InnerClass2 innerClass2 = new InnerClass2();
innerClass2.display();
}
public static void main(String[] args) {
OuterClass2 outerClass = new OuterClass2();
outerClass.display();
}
}
结果:
静态内部类
静态内部类的构造不需要依赖于外部类对象,类中所有静态组件都不需要依赖任何对象,可以直接对类本身构造
package com.ycz.test;
/**
* @Description:
* @Author: Alex
* @Date 2022-07-06-16:11
* @Version: V1.0
**/
public class OuterClassStatic {
private String outerName;
public void display(){
System.out.println("outer class display");
}
public static class InnerClassStatic{
private String innerName;
public InnerClassStatic(){
innerName = "inner class";
}
public void display(){
System.out.println("inner class display");
System.out.println(innerName);
}
}
public static void main(String[] args) {
OuterClassStatic outerClassStatic = new OuterClassStatic();
outerClassStatic.display();
InnerClassStatic innerClassStatic = new InnerClassStatic();
innerClassStatic.display();
}
}
结果:
匿名内部类
package com.ycz.test;
/**
* @Description:
* @Author: Alex
* @Date 2022-07-06-16:17
* @Version: V1.0
**/
public interface MyInterface {
public void test();
}
package com.ycz.test;
/**
* @Description:
* @Author: Alex
* @Date 2022-07-06-16:17
* @Version: V1.0
**/
public class MyImplement implements MyInterface{
@Override
public void test() {
System.out.println("test1");
}
}
package com.ycz.test;
/**
* @Description:
* @Author: Alex
* @Date 2022-07-06-16:29
* @Version: V1.0
**/
public class Test {
public static void main(String[] args) {
MyInterface myInterface = new MyImplement();
myInterface.test();
//这个就是匿名内部类
MyInterface myInterface1 = new MyInterface() {
@Override
public void test() {
System.out.println("test2");
}
};
myInterface1.test();
}
}
结果: