一.内部类分类
1.成员内部类(可以理解为成员变量)
2.静态内部类 (可可以理解为静态变量)
3.局部内部类 (可以理解为局部变量)
4.匿名内部类
二.成员内部类
1.成员内部类相当于类的成员变量,可以用访问修饰符修饰(private,public,protected,默认修饰符)
2.成员内部类不能有静态变量和静态方法
3.成员内部类可以访问外部类的所有资源(静态变量方法,成员变量方法)
4.内部使用: InnerClass inner = new InnerClass(); inner.调用
5.外部使用: OuterClass.InnerClass innerClass = new OuterClass().new InnerClass(); innerClass.调用
package com.test;
public class OuterClass {
private String outmenber = "外部类成员变量";
public static String outstatic = "外部类静态变量";
public void outmethor(){
System.out.println("外部类成员方法");
}
public static void outStaticMethor(){
System.out.println("外部类静态方法");
}
/**
* 1.成员内部类相当于类的成员变量,可以用访问修饰符修饰(private,public,protected,默认修饰符)
* 2.成员内部类不能有静态变量和静态方法
* 3.成员内部类可以访问外部类的所有资源(静态变量方法,成员变量方法)
* 4.内部使用: InnerClass inner = new InnerClass(); inner.调用
* 5.外部使用: OuterClass.InnerClass innerClass = new OuterClass().new InnerClass(); innerClass.调用
*/
class InnerClass{
private String innermenber = "内部类成员属性";
//public static String innerStaticMember = "内部类静态变量"; 成员内部类不允许有静态变量和方法
private void innerMethor(){
System.out.println("内部类方法");
System.out.println("访问外部类成员变量:"+outmenber);
System.out.println(outstatic);
outmethor();
outStaticMethor();
}
public void innerMethor2(){
System.out.println("内部类========");
}
}
public void useInner(){
InnerClass innerClass = new InnerClass();
innerClass.innerMethor();
System.out.println(innerClass.innermenber);
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
outerClass.useInner();
}
}
class OutTest{
public static void main(String[] args) {
OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
innerClass.innerMethor2();
}
}
三.静态内部类
1.静态内部类相当于外部类的静态变量,可以用任意访问修饰符修饰
2.静态内部类可以有静态变量及方法,成员变量及方法
3.静态内部类只能访问外部类的静态变量和方法
4.外部类内部使用: 分为访问静态变量/方法(类名.直接调用给)和访问成员变量及方法(通过对象调用)
5.类外部访问:
OuterClass2.InnerClass2.inStaticMethor(); //调用静态变量及方法
OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2(); //创建对象调用成员变量及方法
package com.test;
public class OuterClass2 {
private String str1 ="str1";
private static String str2 ="static menber";
public void outMethor(){
System.out.println("outMethor");
}
public static void outStaticMethor(){
System.out.println("outStaticMethor");
}
/**
* 静态内部类
* 1.静态内部类相当于外部类的静态变量,可以用任意访问修饰符修饰
* 2.静态内部类可以有静态变量及方法,成员变量及方法
* 3.静态内部类只能访问外部类的静态变量和方法
* 4.外部类内部使用: 分为访问静态变量/方法(类名.直接调用给)和访问成员变量及方法(通过对象调用)
* 5.类外部访问:
* OuterClass2.InnerClass2.inStaticMethor(); //调用静态变量及方法
* OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2(); //创建对象调用成员变量及方法
*/
static class InnerClass2{
private String instr = "instr";
private static String inStaticStr = "inStaticStr";
public void inmethor(){
System.out.println("this is inmethor");
System.out.println(str2); //只能访问静态变量及方法
outStaticMethor();
}
public static void inStaticMethor(){
System.out.println("this is inStaticMethor");
System.out.println(str2);
outStaticMethor();
}
}
public void userStaticInnerClass(){
InnerClass2.inStaticMethor();
System.out.println(InnerClass2.inStaticStr);
InnerClass2 innerClass2 = new InnerClass2();
innerClass2.inmethor();
System.out.println(innerClass2.instr);
System.out.println(innerClass2.inStaticStr);
innerClass2.inStaticMethor();
}
}
class OutTest2{
public static void main(String[] args) {
OuterClass2.InnerClass2.inStaticMethor(); //调用静态变量及方法
OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2(); //创建对象
innerClass2.inmethor(); //调用成员变量及方法
}
}
三.局部内部类
局部内部类
1.局部内部类相当于局部变量,不能用访问修饰符修饰
2.不能拥有静态变量及方法,和成员内部类一样
3.静态方法里的局部内部类只能方位外部类的静态变量及方法,成员方法的局部内部类访问外部类的所有资源
4.只能在定义局部内部类的方法里创建局部内部类对象调用
5.不能修改方法里的局部变量,但可以修改外部类的静态变量,成员变量
package com.test;
public class OuterClass3 {
private static int x = 100;
private String str1 ="str1";
private static String str2 ="static menber";
public void outMethor(){
System.out.println("outMethor");
}
public static void outStaticMethor(){
System.out.println("outStaticMethor");
}
public static void outStaticMethor2(){
int k = 10;
System.out.println("outStaticMethor");
/**
* 局部内部类
* 1.局部内部类相当于局部变量,不能用访问修饰符修饰
* 2.不能拥有静态变量及方法,和成员内部类一样
* 3.静态方法里的局部内部类只能方位外部类的静态变量及方法,成员方法的局部内部类访问外部类的所有资源
* 4.只能在定义局部内部类的方法里创建局部内部类对象调用,作用域在定义它的方法里
* 5.不能修改方法里的局部变量,但可以修改外部类的静态变量,成员变量
*/
class InnerClass3{
private int a = 10;
public void innerMethor(){
System.out.println(a);
System.out.println(str2);
x++;
}
}
InnerClass3 innerClass3 = new InnerClass3();
innerClass3.innerMethor();
}
public static void main(String[] args) {
outStaticMethor2();
}
}
四.匿名内部类
1.匿名内部类只使用一次,没有名字,通过 new 类名(){} 创建,和局部内部类一样不能修改方法里的局部变量,可以和局部内部类一样去理解匿名内部类
package com.test;
public class NiClass {
static int k = 300;
public static void main(String[] args) {
int t = 200;
//相当于创建类A的子类,通过向上造型父类引用了子类
A a = new A(){
//重写方法a1
public void a1(){
System.out.println("我是匿名内部类,重写了a1方法");
}
//重写方法a2
public int a2(int a,int b){
return a*b;
}
public void a3(){
k++; //可以修改外部类的资源,由于是在静态方法定义的所以只能访问静态资源
}
};
a.a1();
int sum = a.a2(5,4);
System.out.println(sum);
}
}
class A{
public void a1(){
System.out.println("methor a1");
}
public int a2(int a,int b){
return a+b;
}
}