标签：练习题 Java 内部 void System println new public out

内部类简介

package chapter11;
​
public class InnerClass01 {//外部其他类
    public static void main(String[] args) {
​
    }
}
class Outer{//类的构成：属性，方法，构造器，代码块，内部类
    private int n1=100;
    public Outer(int n1){
        this.n1=n1;
    }
    public void m1(){
        System.out.println("m1()");
    }
    {
        System.out.println("代码块...");
    }
    class Inner{//内部类
​
    }
}

package chapter11;
​
public class InnerClassExercise01 {
    public static void main(String[] args) {
​
        //当实参直接传递，简洁高效
    f1(new IL() {//只用一次
        @Override
        public void show() {
            System.out.println("这是一幅名画");
        }
    });
    f1(new Picture());//传统方法
    }
    public static void f1(IL il){//形参是接口类型
        il.show();
    }
}
interface IL{
    void show();
}
//传统方法实现接口，硬编码
class Picture implements IL{
​
    @Override
    public void show() {
        System.out.println("这是一幅名画..");
    }
}

package chapter11;
​
public class InnerClassExercise02 {
    public static void main(String[] args) {
        CellPhone cellPhone = new CellPhone();
        cellPhone.alarmclock(new Bell() {//传递的是实现Bell接口的匿名内部类，重写了ring
            /*
            Bell bell =new Bell(){ 匿名内部类运行类型InnerClassExercise02$
              @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
            }
             */
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        cellPhone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("上课了");
            }
        });
​
    }
}
interface Bell{
    void ring();
}
class CellPhone{
    public void alarmclock(Bell bell){
        System.out.println(bell.getClass());//运行类型 InnerClassExercise02$ 断点可看
        bell.ring();//动态绑定到InnerClassExercise02$里
    }
}

局部内部类

package chapter11;
​
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.m1();
        System.out.println(outer02);
​
    }
}
class Outer02{//外部类
    private int n1=100;
    private int n2=100;
    private void m2(){
        System.out.println("m2执行");
    };
    public void m1(){
        class Inner02{ //局部内部类，定义在外部类的局部位置，通常在方法中，可访问外部类所有成员（包含私有），不能加修饰符除了final（不能被继承），作用域在该方法体内
            private int n2=123;
            public void f1(){
                System.out.println("n1="+n1);
                System.out.println(n2+"外部类n2"+Outer02.this.n2);//就近原则n2 Outer02.this就是外部类对象
                System.out.println(Outer02.this);
                m2();
            }
        }
        class Inner03 extends Inner02{//局部内部类可继承
​
        }
        new Inner02().f1();//方法体内调用内部类方法，new类
    }
​
}

成员内部类

package chapter11;
​
public class MemberInnerClass01 {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.ti();
        Outer01.Inner01 inner01=outer01.new Inner01();//第一种方式 把 new Inner01()看作outer01成员
        inner01.say();
        Outer01.Inner01 inner01Instance = outer01.getInner01Instance();//第二种 在外部类中编写方法，返回Inner01对象
        inner01Instance.say();
​
    }
}
class Outer01{
    private int n1=10;
    public String name="张三";
    private void hi(){
        System.out.println("666");
    }
    public class Inner01{//成员内部类，在外部类的成员位置上，可加任意修饰符（无static），作用域为整个类体
        public double sal=99.8;
        public void say(){
            //成员内部类，可直接访问外部类所有成员，包含私有的，但遵循就近原则（Outer01.this.访问外部类属性）
            System.out.println("Outer01的n1="+n1+"\touter01的name="+name);
            hi();
        }
    }
​
    public void ti(){
        //使用成员内部类
        Inner01 inner01 = new Inner01();
        inner01.say();
        System.out.println(inner01.sal);//外部类创建对象再访问内部类属性
    }
    //返回一个Inner01实例
    public Inner01 getInner01Instance(){
        return new Inner01();
    }
}

匿名内部类

package chapter11;
​
public class AnonymousInnerClass {
    public static void main(String[] args) {
      new Outer04().method();
    }
}
class Outer04{//外部类
    private int n1=10;//属性
    public void method(){//方法
        //基于接口的匿名内部类
        Tiger tiger = new Tiger();//想要实现接口并创建对象，传统方法时写类实现接口并创建对象
        tiger.cry();
        IA dog =new IA(){//只用一次，基于接口的匿名内部类简化开发 编译类型IA，运行类型是匿名内部类
            //创建匿名内部类 Outer04$1 立马就创建了Outer04$1实例，并把地址给了dog
            /*
          class xxx implements IA{  xxx=Outer04$1 分配类名
         @Override
         public void cry() {
         System.out.println("小狗叫了"); }
                                    }
             */
            @Override
            public void cry() {
                System.out.println("小狗叫了");
            }
        };
        System.out.println("tiger运行类型"+tiger.getClass());
        dog.cry();
        System.out.println("dog运行类型"+dog.getClass());
        Father father = new Father("jack") {//基于类的匿名内部类（不打大括号是创建对象） 编译类型Father 运行类型Outer04$2 没有大括号则变Father
            /*
            class Outer04$2 extends Father{
               @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
            }
             */
​
            @Override//不重写相当于上边也没重写方法
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        System.out.println("father对象的运行类型="+father.getClass());
        father.test();
        //基于抽象类的匿名内部类
        Animal animal = new Animal() {
            @Override
            void eat() {
                System.out.println("抽象类的匿名内部类");
            }
        };
        animal.eat();
    }
}
interface IA{
    public void cry();
}
class Tiger implements IA{
​
    @Override
    public void cry() {
        System.out.println("老虎叫了");
    }
}
class Father{
    public Father(String name){
        System.out.println("接收name="+name);
    }
    public void test(){
​
    }
}
abstract  class  Animal{
    abstract void eat();
}

package chapter11;
​
public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.fi();
        System.out.println(outer05);
    }
}
class Outer05{
    private int n1=99;
    private int n2=97;
    public void fi(){
        //创建一个基于类的匿名内部类，作用域仅仅在定义它的方法或代码块中
        Person p =new Person(){
            private  int n2=98;
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了 hi方法"+n1);//可以直接访问外部类所有成员
                System.out.println("就近原则访问"+n2);//外部类和内部类属性重名，按就近原则
                System.out.println("外部类的n1="+Outer05.this.n1);//访问外部类的同名属性+Outer05.this.n1 它就是调用fi对对象
                System.out.println(Outer05.this);
            }
        };
        p.hi();//动态绑定，运行类型是 Outer05$1 不会输出原来的hi
        //也可以直接调用
        new Person(){//新的匿名内部类 也是个对象，可直接调用hi
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了 hi方法 haha");
            }
​
            @Override
            public void ok(String str) {
                super.ok(str);//class 匿名内部类 extends Person
            }
        }.ok("666");
​
    }
}
class Person{
    public void hi(){
        System.out.println("Person hi()");
    }
    public void ok(String str){
        System.out.println("Person ok()"+str);
    }
}

静态内部类

package chapter11;
​
public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer03 outer03 = new Outer03();
        outer03.m1();
        Outer03.Inner03 inner03 = new Outer03.Inner03();
        inner03.say();
        Outer03.Inner03 inner031 = outer03.getinner03();
        inner031.say();
        Outer03.Inner03 inner032 = outer03.getinner03();
        inner032.say();
​
​
    }
}
class Outer03{
    private int n1=10;
    private static String name="张三";
    private static void cry(){
        System.out.println("外部类成员方法");
    };
    //静态内部类 放在外部类成员位置 static修饰 作用域整个类体
    //可直接访问外部类所有静态成员，包括私有，但不能访问非静态成员
    static class Inner03{ //可加任意修饰符
        private static String name="李四";
        public void say(){
            System.out.println(name);//就近原则
            System.out.println("外部类name="+Outer03.name);//静态不用在this
            cry();
        }
​
    }
    public void m1(){
        Inner03 inner03 = new Inner03();//外部类创建对象访问内部类
        inner03.say();
    }
    public Inner03 getinner03(){
        return new Inner03();
    }
    public static Inner03 getInner03(){
        return new Inner03();
    }
}

练习题

package chapter11;
​
public class Test {
    public Test() {
        Inner s1=new Inner();
        s1.a=10;
        Inner s2 = new Inner();
        System.out.println(s2.a);//5
    }
    class Inner{
        public int a=5;
    }
​
    public static void main(String[] args) {
        Test t = new Test();
        Inner r = t.new Inner();
        System.out.println(r.a);//5
    }
​
}

标签：练习题,Java,内部,void,System,println,new,public,out
来源： https://www.cnblogs.com/wybqjcdd/p/16074311.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。