10.21作业(Java)

d08

1:教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类

//接口

publicinterface LearnEnglish {

       publicabstractvoidLearnEnglish();

}

 //运动员的抽象类

publicabstractclass Athletes {

       //成员变量

       private Stringname;

       privateintage;

       public Athletes(){

              super();

       }

       public Athletes(Stringname,intage) {

              super();

              this.name=name;

              this.age=age;

       }

       //setXXX,getXXX

       public String getName() {

              returnthis.name;

       }

       publicvoid setName(Stringname) {

              this.name=name;

       }

       publicint getAge() {

              returnthis.age;

       }

       publicvoid setAge(intage) {

              this.age=age;

       }

       //抽象功能

       publicabstractvoid train();

       publicabstractvoid competition();

       //非抽象功能

       publicvoid sleep() {

              System.out.println("训练完就睡觉");

       }

}

//子类

publicclass Paddlerextends Athletes {

       public Paddler() {

              super();

       }

       public Paddler(Stringname ,intage) {

              super(name,age);

             

       }

      

       @Override

       publicvoid train() {

              System.out.println("乒乓球训练");

 

       }

       publicvoid competition() {

              System.out.println("乒乓球比赛");

       }

}

//子实现类

publicclass LearnEnglishHoopmanextends Hoopmanimplements LearnEnglish {

       public LearnEnglishHoopman() {

              super();

       }

       public LearnEnglishHoopman(Stringname,intage) {

              super(name,age);

       }

      

       @Override

       publicvoid LearnEnglish() {

              System.out.println("我要学英语");

 

       }

 

}

//子实现类

publicclass LearnEnglishPaddlerextends Paddlerimplements LearnEnglish {

       public LearnEnglishPaddler() {

              super();

       }

       public LearnEnglishPaddler(Stringname,intage) {

              super(name,age);

       }

       @Override

       publicvoid LearnEnglish() {

              System.out.println("我要学英语");

 

       }

 

}

//测试类

publicclass InterfaceTest3 {

       publicstaticvoid main(String[]args) {

              LearnEnglishHoopmanhp =new LearnEnglishHoopman();

              hp.LearnEnglish();

              hp.setAge(25);

              hp.setName("姚明");

              hp.competition();

              hp.sleep();

              hp.train();

              System.out.println(hp.getAge()+"----"+hp.getName());

             

       }

}

抽象类:Athletes

接口:LearnEnglish

具体类: Paddler  LearnEnglishHoopman  LearnEnglishPaddler  InterfaceTest3

 

2.final关键字

a.final修饰类

final如果修饰一个类，该类不能被继承.

 

b.final修饰类的成员变量

该成员变量的值不可修改。

 

3. 问题: 那么什么时候初始化这个值?

 

在对象创建之前都可以.

a.构造代码块中可以进行初始化

b.构造方法中可以进行初始化

c.定义成员变量的时候，可以直接进行初始化.

 

注意一点: 这三种方式同时只能用一种。

 

4:多态是什么，前提是什么?

多态:一个事物在不同时刻体现出来的不同状态

对于多态的三个前提条件

 

                 1)条件1:必须有继承关系(如果没有继承关系,谈不上多态!)

                 2)条件2:必须有方法重写

                                    子类出现了父类一样的 方法声明

                 3)有父类引用指向子类对象:向上转型

                           Fu f = new Zi() ;

                 多态的三个条缺一不可!

5:多态中成员访问的特点?

        

                 成员变量:

                                    编译看左边,运行看左边

                 成员方法(非静态的成员方法):

编译看左,运行看右;由于存在方法重写,所以就运行最终的就是子类的成员方法

                 静态成员方法:(静态方法算不上方法重写,静态直接跟类有关系!)

                                    编译看左,运行看左

                 构造方法:还是对象进行初始化,由于是一种继承关系,还是分层初始化!

6:多态的好处及弊端？如何解决多态的弊端？

多态的好处(特点):

 

                1)提高代码的维护性(由继承保证)

                2)提高代码的扩展性(由多态保证)

多态的弊端:

                 不能访问子类的特有功能

解决方案:

                         1)创建子类的具体对象,来访问自己的特有功能;虽然可以解决多态的弊端,但是从内存角度考虑,需要创建子类对象,那么必须在堆内存开辟空间,耗费内存,浪费空间!

                         2)既然多态的第三个前提条件:父类引用指向子类对象,那么可不可以将子类

                        可以的:向下转型:将父类的引用强制转换为子类的引用:前提必须有父类的引用存在;

                   向下转型必须依赖于向上转型!

7:什么是向上转型？什么是向下转型？

向上转型:父类引用指向子类对象

Fu f = new Zi();

向下转型:子类引用指向父类对象

Zi z = (Zi)f;

 

8. 抽象类概述及其特点?

当一个类中如果有抽象功能(抽象方法)的时候,那么这个类一定要定义为抽象类!

抽象类不能实例化:抽象类不能创建对象

9:抽象类成员特点?

成员变量:

                                            可以是变量也可以是自定义常量

                         构造方法:

                                            抽象类可以有构造方法:包括有参构造和无参构造

                                            作用:通过抽象类多态的形式:让子类进行数据的初始化

                         成员方法:

                                            可以有抽象方法,也可以有非抽象方法

10:抽象类的小问题

         A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

         B:abstract不能和哪些关键字共存

                   可以

                不能让其创建对象!

 

 abstract不能和哪些关键字共同使用?

       private 和abstract不能共同使用

       final和abstract不能共同使用

       static和abstract不能共同使用

11:接口的概述及其特点?

接口体现的是一种:扩展功能:                比如:猫可以跳高(并不是所有的猫都具有跳高功能)

接口的特点:不能实例化(不能直接创建对象)

12:接口的成员特点?

成员变量:

                                   只能是常量:存下默认修饰符:publicstatic final (永远建议自己给出默认修饰符)

                构造方法:

                                   接口是没有构造方法的

                成员方法:

                                   接口中的成员方法默认修饰符:publicabstract(永远建议自己给出默认修饰符)

13:抽象类和接口的区别?

1)成员的区别:

                           成员变量:

                                    抽象类:成员变量可以是常量,也可以是变量

                                    接口:成员变量只能是一常量:存在默认修饰符:publicstatic final

                           构造方法:

                                    抽象类:可以有无参构造,有参构造方法

                                               作用:通过子类进行数据初始化(通过子类创建对象)

                                    接口:没有构造方法的

                           成员方法的区别:

                                    抽象类:可以有抽象方法,也可以有非抽象方法

                                    接口:只能是抽象方法:存在默认修饰符:publicabstract

                                   

                 2)关系的区别:

                           类与类的关系:

                                   继承关系:extends,java中只支持单继承,不支持多继承,但是可以多层继承!

                                   类与接口的关系:

                                            实现关系:implements,并且,一个类在继承另一个类的同时,可以实现多个接口

                                             (class子实现类名  enxtends Object implements 接口名1,接口名2...)

                        

                                   接口与接口的关系

                                                     继承关系:extends,可以支持单继承,也可以多继承!

                                                    

                3)设计理念的区别:

                                   抽象类:

                                            体现的是一种"isa"的关系,存在继承关系!(抽象类多态)

                                   接口:

                                            体现的是一种"likea"的关系,由于接口的一种扩展功能

 

D09

 

1. 内部类的概述及访问特点

在一个类中定义另一个类,那么把这种情况:内部类

内部类是直接可以访问外部类的成员,包括私有外部类想要访问内部类的成员,必须通过创建内部类的对象访问该内部类的成员

2.内部类的分类

成员内部类:在外部类的成员位置

                 局部内部类:在外部了的局部位置定义的这个类

3.匿名内部类的格式和应用及面试题

匿名内部类

                是内部类的简化版格式

  前提条件:

                必须存在一个接口或者是一个类(可以是具体类,也可以是一个抽象类)

 

  书写的格式:

                         new 接口名或者类名(){

                                   方法重写;

                         }

 

                匿名内部类的实质:

                                            继承了该类(抽象类)或者是实现了该接口的子类对象!

匿名内部类面试题：

                   按照要求，补齐代码

                            interfaceInter { void show(); }

                            classOuter { //补齐代码 }

                            classOuterDemo {

                                     publicstatic void main(String[] args) {

                                                 Outer.method().show();

                                       }

                            }

                            要求在控制台输出”HelloWorld”

 

//接口

interface Inter2{

//      voidshow() ;

         publicabstract void show() ;

}

 

class Outer8{

         //补齐代码

         publicstatic Inter2  method(){ //返回值是一个接口

                  

                   returnnew Inter2(){

 

                            @Override

                            publicvoid show() {

                                     System.out.println("helloworld");

                            }

                           

                   };

                  

         }

}

 

//测试类

public class InnerClassTest2 {

         publicstatic void main(String[] args) {

                    Outer8.method().show();

                    

                    //当前method()能直接被类名调用---->method()方法是一个静态方法  static

                    //Outer8.method().show()---->Outer8.method()返回的是一个对象,拿对象调用show()方法

                    //由于接口只有一个show()方法,最终要去重写show()方法

                    

                             

         }

}