java 67 内部类

置顶学习一直在路上

已于 2022-02-15 14:01:35 修改

阅读量281

点赞数

分类专栏： JVM 文章标签： java 开发语言后端

于 2022-02-15 14:00:22 首次发布

本文链接：https://blog.csdn.net/weixin_38204966/article/details/122943216

版权

JVM 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

package com.company;
//内部类
//内部类就是在一个类的内部定义的类
// 2.方法内部类。在一个类中的方法定义内部类
//静态内部类：在一个类内部定义，一个静态内部类，静态的含义是该内部可以像其他静态成员一样，没有外部类对象时。也能访问它，
//静态嵌套仅能访问，外部类的静态成员和方法

//public class test67 {
// public static void main(String [] args){
// Outer outer =new Outer();
// //在外部创建成员内部类的实列，因为成员类部类，需要依赖外部的对象
// //通常不建议这样用
// Outer.Inner inner=outer.new Inner();
// inner.print();
// // 可以把内部类设置成一个方法，建议用这种方式
// outer.innerPrint();
// outer.show();
//
// }
//}
成员类部类
//class Outer{
// private String name;
// // 自己的内部内。加私有的访问修饰符
// // 建议在外部方法内部类。
// // 内部类可以作为一个类的外部成员，
// public void innerPrint(){
// Inner inner=new Inner();
// inner.print();
//
// }
// class Inner{
// public void print(){
// System.out.println(“inner”);
// }
// }
//
// //2方法内部类 show 方法的局部变量或方法的参数，实际必须是常量 final .
// public void show(){
// final int x=10;
// class Inner2 {
//
// public void print(){
// System.out.println(“方法内部类” +x);
// }
// }
// Inner2 inner2=new Inner2();
// inner2.print();
//
// }
//
//}

//静态类不类
//3.静态内部类，在类中定义一个静态修饰的内部类，静态的含义是该内部类，可以像其他静态成员一样，没有外部类对象时，也能够访问它，静态嵌套仅能方位外部类的静态成员和方法
public class test67 {
public static void main(String [] args){
Outer outer =new Outer();
//在外部创建成员内部类的实列，因为成员类部类，需要依赖外部的对象
//通常不建议这样用
// Outer.Inner inner=outer.new Inner();
// inner.print();
// 可以把内部类设置成一个方法，建议用这种方式
outer.innerPrint();
outer.show();
// outer.Inner3 inner3= new outer.Inner3();
// inner3.print();
outer.print2();
//参数内部类

}
//成员类部类
class Outer{

private  String name;
//  自己的内部内。加私有的访问修饰符
// 建议在外部方法内部类。
// 内部类可以作为一个类的外部成员，
public void innerPrint(){
    Inner inner=new Inner();
    inner.print();

}
class  Inner{
    public void print(){
        System.out.println("inner");
    }
}

//2方法内部类  show 方法的局部变量或方法的参数，实际必须是常量 final .
public  void show(){
    final int x=10;
    class  Inner2 {

        public void  print(){
            System.out.println("方法内部类" +x);
        }
    }
    Inner2 inner2=new Inner2();
    inner2.print();

}
static  class Inner3{
    public void  print(){
        System.out.println("静态类部类");
    }
}
//匿名内部内
public  void  print1(){
    Cat cat=new Cat(){
      public  void eat(){
          System.out.println("这个我也不懂");
      }
    };
}
public void  print2(){
    Eat eat=new Eat(){
        public void eat(){
            System.out.println("eat:接口是倪密内部444444444");
        }
    };
    eat.eat();
}

}
interface Eat{
public void eat();
}
abstract class Cat{

public abstract void  eat();

};
//内部类
//当调用
public class Outer {
2 //定义一个实例变量和一个静态变量
3 private int a;
4 private static int b;
5 //定义一个静态方法和一个非静态方法
6 public static void say(){}
7 public void test(){
8 //在外部类中调用内部类的属性和方法
9 Outer.Inner.c = 1; //可以通过静态内部类的全类名来调用静态内部类的静态属性（外部类名.静态内部类名.属性）
10 Outer.Inner.go(); //可以通过静态内部类的全类名来调用静态内部类的静态方法（外部类名.静态内部类名.方法）
11 //Outer.Inner.walk(); //不能通过类静态内部类的全类名来调用内部类的非静态属性和方法
12 Inner inner = new Inner();
13 inner.d = 1;
14 inner.walk(); //可以通过创建内部类实例来调用静态内部类的非静态属性和方法
15 }
16 //静态内部类
17 public static class Inner{
18 //在静态内部类中定义一个静态变量和一个实例变量
19 static int c;
20 int d;
21 //定义一个匿名代码块和一个静态代码块
22 {}
23 static{}
24 //定义一个静态方法和一个普通方法
25 public static void go(){}
26 public void walk(){
27 //在静态内部类中调用外部类的属性和方法
28 int f = b; //可以直接调用外部类的静态属性
29 say(); //可以直接调用外部类的静态方法
30 //int e = a; 直接调用外部类的非静态属性出错编译出错
31 //test(); 直接调用外部类的非静态方法时编译出错
32 Outer outer = new Outer();
33 int e = outer.a; //可以通过创建外部类实例来调用外部类的非静态属性
34 outer.test(); //可以通过创建外部类实例来调用外部类的非静态方法
35 }
36 }
37 }