day 11：Java中的内部类、匿名内部类和一道例题

最新推荐文章于 2022-03-31 17:23:32 发布

bamzhy13

最新推荐文章于 2022-03-31 17:23:32 发布

阅读量206

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/qq_37366958/article/details/79063841

版权

JavaSE 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

package bamzhy.day13;

//    乒乓球运动员和篮球运动员,乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都必须学习英语。
//      请用所学知识分析，这个案例中有哪些抽象类、接口、具体类。
public class Example {
    public static void main(String[] args) {
        PingpongPlayer pingPongPlayer1=new PingpongPlayer("张怡宁",true,25);
        System.out.println("name = " + pingPongPlayer1.name + " isFemale = " + pingPongPlayer1.isFemale + " career = "
                + pingPongPlayer1.carrer);
        pingPongPlayer1.eat();
        pingPongPlayer1.practice();

    }

}

abstract class Person{

    String name;
    boolean isFemale;
    public Person(){

    }

    public Person(String name, boolean isFemale) {
    this.name=name;
    this.isFemale=isFemale;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public boolean isFemale() {
        return isFemale;
    }

    public void setFemale(boolean female) {
        isFemale = female;
    }
    public  void sleep(){
        System.out.println("人都躺着睡");
    }
    //吃饭这个动作对于不同类型的运动员和教练员来说可能并不相同，无法确定此时究竟吃什么
    public abstract void eat();
}
abstract class Player extends Person{

    int carrer;
    public Player(){}
    public Player(int carrer){
        this.carrer=carrer;
    }
    public Player(String name,boolean isFemale,int carrer){
        super(name,isFemale);//向上传参数
        this.carrer=carrer;
    }
    public int getCarrer() {
        return carrer;
    }

    public void setCarrer(int carrer) {
        this.carrer = carrer;
    }
    //站在运动员的角度，还是没有办法确定具体的训练内容
    public abstract void practice();
}

abstract class Coach extends Person{
    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    String status;
    public Coach(){
    }
    public abstract void train();
}

interface InterfaceInternationally{
    void speakEnglish();
}

class PingpongPlayer extends Player implements InterfaceInternationally{

    public PingpongPlayer(String name,boolean isFemale,int carrer) {
        super(name,isFemale,carrer);
    }

    @Override
    public void eat() {
        System.out.println("均衡搭配，营养丰富");
    }

    @Override
    public void practice() {
        System.out.println("训练乒乓球技巧");
    }

    @Override
    public void speakEnglish() {
        System.out.println("学习英语技能");
    }
}

class BasketballPlayer extends Player{
    @Override
    public void eat() {
        System.out.println("高蛋白饮食");
    }

    @Override
    public void practice() {
        System.out.println("训练篮球技巧");
    }
}

class PingPongCoach extends Coach implements InterfaceInternationally{
    @Override
    public void eat() {
        System.out.println("均衡搭配，营养丰富");
    }

    @Override
    public void train() {
        System.out.println("指导乒乓球运动员");
    }

    @Override
    public void speakEnglish() {
        System.out.println("熟练掌握英语技能");
    }
}
class BasketbalCoach extends Coach{
    @Override
    public void eat() {
        System.out.println("补脑食物");
    }
    @Override
    public void train() {
        System.out.println("给篮球运动员提供战术指导");
    }
}

内部类：

package bamzhy.day12;

public class InnerClassDemo2 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.accessInner();
//        Outer.Inner in=new Outer.Inner()；
        //没有静态(static)的类中类不能使用外部类进行.操作,必须用实例来进行实例化类中类.
        Outer outer1=new Outer();
        //从外部类的外部访问成员位置局部变量的正确语法
        //外部类名.内部类名 对象名=外部类对象.内部类对象
        Outer.Inner inner=outer1.new Inner();
        //第二种语法
        Outer.Inner inner2=new Outer().new Inner();
        //匿名对象：没有引用变量指向它，用完就成为垃圾
        //匿名对象不可以复用，只在使用一次的场景想使用；
        new Outer().accessInner();
        Outer[] outers={new Outer()};

    }
}
class Outer{
    int j=100;
    public void accessInner(){
        //外部类内部访问局部内部类
        Inner inner = new Inner();
        System.out.println("inner i="+inner.i);
    }
    class Inner{
        int i=10;
    }
}

package bamzhy.day12;

public class InnerClassDemo3 {
    public static void main(String[] args) {
    Outer1 outer1=new Outer1();
//    Outer1.Inner1 inner1 = outer1.new Inner1();
        //内部类中无论是静态或者非静态方法都可以用对象去访问
        Outer1.Inner1 inner1=new Outer1.Inner1();
        inner1.accessOuter();
        inner1.staticAccessOuter();
        //对于内部类中的静态成员
        //外部类名.内部类名.方法名（）
//        Outer1.Inner1.staticAccessOuter();
        System.out.println("inner static field access:"+Outer1.Inner1.k);
    }
}
//static修饰符不能用来修饰普通类
class Outer1 {
    int i = 10;
    static private int j = 10;

    //一旦内部类被static修饰符所修改时，那么整个内部类的的类体都会变成静态环境
    static class Inner1 {
        static int k = 100;
        int j = 1000;
        public void accessOuter() {
            System.out.println("inner non static j=" + j);
        }

        public static void staticAccessOuter() {
            System.out.println("inner static j=" + new Outer1().j);
            System.out.println("inner static j=" + new Inner1().j);
        }

    }
}
匿名内部类：
public class AnonymousInnerClass {
    //是内部类的一种简化写法
    //（对象）new 类名或者接口名（）{重写方法}
    //匿名内部类的本质：是一个继承了类或者实现了接口的子类匿名对象
    public static void main(String[] args) {
        Inter1 inter=new A();
        //首先匿名内部类的结构是一个实现了接口或者抽象类的匿名对象
        //因为它是一个匿名对象，在只会被使用一次的场景下使用
        new A().show();
        new Inter1(){
            @Override
            public void show() {
                System.out.println("class A implements Inter1");
            }
        }.show();
    }
}
interface Inter1{
    void show();
}
class A implements Inter1{
    @Override
    public void show() {
        System.out.println("class A implements Inter1");
    }
}

public class AnonymousInnerClass2 {
    /*
    匿名内部类的使用
     */
    public static void main(String[] args) {
        new Inner2(){
            @Override
            public Inner2 toDo() {
                System.out.println("to do");
                return  this;
            }

            @Override
            public void toBuy() {
                System.out.println("to Buy");
            }
        }.toBuy();
        //当要在一个匿名内部类对象上调用两个方法或者调用多次，new出多个匿名内部类对象
        new Inner2(){
            @Override
            public Inner2 toDo() {
                System.out.println("to do");
                return this;
            }

            @Override
            public void toBuy() {
                System.out.println("to Buy");
            }
        }.toBuy();
        //第二种调用方式
        Inner2 inner2 = new Inner2(){
            @Override
            public Inner2 toDo() {
                System.out.println("to do");
                return this;
            }

            @Override
            public void toBuy() {
                System.out.println("to Buy");
            }
        };
        inner2.toBuy();
        inner2.toDo();
        //实现链式调用
        new Inner2(){
            @Override
            public Inner2 toDo() {
                System.out.println("to do");
                return this;
            }
            @Override
            public void toBuy() {

            }
        }.toDo().toDo();
    }
}
interface Inner2{
    Inner2 toDo();
    void toBuy();