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

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(){@Overridepublic void show() {System.out.println("class A implements Inter1");}}.show();}}interface Inter1{void show();}class A implements Inter1{@Overridepublic 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();