【JAVA_SE】作业练习1021
1:教练和运动员案例
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类
//测试类
public class Demo {
public static void main(String[] args) {
GoAbroadPingpongAthletes pa1=new GoAbroadPingpongAthletes("张继科",23);
pa1.eat();
pa1.playPingpong();
pa1.speakEnglish();
System.out.println("------------------------------");
GoAbroadPingpongCoach pc1=new GoAbroadPingpongCoach("刘国梁",55);
pc1.eat();
pc1.teachPingpong();
pc1.speakEnglish();
System.out.println("------------------------------");
BasketballAthletes ba1=new BasketballAthletes("姚明",30);
ba1.eat();
ba1.playBasketball();
System.out.println("------------------------------");
BasketbalCoach bc1=new BasketbalCoach("杜峰",50);
bc1.eat();
bc1.teachBasketball();
}
}
//运动员抽象类
public abstract class Athletes {
private String name;
private int age;
public Athletes() {
}
public Athletes(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//抽象方法，非抽象方法皆可
public void eat(){
System.out.println(this.getName()+"吃得好才能打得好");
}
}
//篮球教练类
public class BasketballAthletes extends Athletes {
public BasketballAthletes() {
super();
}
public BasketballAthletes(String name, int age) {
super(name, age);
}
public void playBasketball(){
System.out.println(this.getName()+"篮球打得好");
}
}
//乒乓球员动员类
public class PingpongAthletes extends Athletes {
public PingpongAthletes() {
super();
}
public PingpongAthletes(String name, int age) {
super(name, age);
}
public void playPingpong(){
System.out.println(this.getName()+"乒乓球打得好");
}
}
//教练抽象类
public abstract class Coach {
private String name;
private int age;
public Coach() {
}
public Coach(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println(this.getName()+"吃得好才能教得好");
}
}
//篮球运动员类
public class BasketbalCoach extends Coach {
public BasketbalCoach() {
super();
}
public BasketbalCoach(String name, int age) {
super(name, age);
}
public void teachBasketball(){
System.out.println(this.getName()+"可以带出优秀的篮球运动员");
}
}
//乒乓球教练类
public class PingpongCoach extends Coach {
public PingpongCoach() {
super();
}
public PingpongCoach(String name, int age) {
super(name, age);
}
public void teachPingpong(){
System.out.println(this.getName()+"可以带出优秀的乒乓球运动员");
}
}
//说英语接口
public interface English {
public abstract void speakEnglish();
}
//出国运动员类
public class GoAbroadPingpongAthletes extends PingpongAthletes implements English {
public GoAbroadPingpongAthletes() {
super();
}
public GoAbroadPingpongAthletes(String name, int age) {
super(name, age);
}
@Override
public void speakEnglish() {
System.out.println(this.getName()+"练出了流利的英语，可以出国了");
}
}
//出国教练类
public class GoAbroadPingpongCoach extends PingpongCoach implements English {
public GoAbroadPingpongCoach() {
super();
}
public GoAbroadPingpongCoach(String name, int age) {
super(name, age);
}
@Override
public void speakEnglish() {
System.out.println(this.getName()+"练出流利的英语，可以出国了");
}
}
运行结果：
张继科吃得好才能打得好
张继科乒乓球打得好
张继科练出了流利的英语，可以出国了
------------------------------
刘国梁吃得好才能教得好
刘国梁可以带出优秀的乒乓球运动员
刘国梁练出流利的英语，可以出国了
------------------------------
姚明吃得好才能打得好
姚明篮球打得好
------------------------------
杜峰吃得好才能教得好
杜峰可以带出优秀的篮球运动员
2. final关键字可以干什么?有什么特点?
1)final修饰基本类型数据时，该变量不能被重新赋值；
2)final修饰一个引用类型变量时，其引用不能重新指向新的对象；
3)final修饰一个方法时，该方法不能被重写；
4)final修饰一个类时，该类不能被继承。
3. final关键字的面试题：
A:修饰局部变量
基本数据类型:如果局部变量是一个基本数据类型,那么被final修饰,基本数据类型的变量的值不能再改变!
引用数据类型:如果用final修饰引用类型的变量,那么它不能在重写分配堆内存空间,但是可以改变可以成员变量的值
B:初始化时机
成员变量：初始化方式一：在定义变量时直接赋值
初始化方式二：声明完变量后在构造方法中为其赋值
初始化方式三：声明完变量后在构造代码块中为其赋值
静态变量：初始化方式一：在定义类变量时直接赋值
初始化方式二：在静态代码块中赋值
4.多态是什么，前提是什么?
多态:一个事物在不同时刻体现出来的不同状态
多态的前提：1)必须存在继承或者实现关系
2)父类引用类型变量指向子类对象
3)必须有方法重写
5.多态中成员访问的特点?
1)多态情况下，子父类存在同名成员时，默认访问父类成员；
只有存在非静态成员方法时才访问子类成员
2)多态情况下，不能访问子类特有成员
6.多态的好处及弊端？如何解决多态的弊端？
多态的好处(特点):
1)提高代码的维护性(由继承保证)
2)提高代码的扩展性(由多态保证)
多态的弊端:
不能访问子类的特有功能
7.什么是向上转型？什么是向下转型？
向上转型：父类引用类型变量指向子类的对象
向下转型：将父类的引用强制转换为子类的引用，前提必须有父类的引用存在，向下转型必须依赖于向上转型。
8.抽象类概述及其特点?
当一个类中如果有抽象功能(抽象方法)的时候,那么这个类一定要定义为抽象类!
特点：1)一个抽象类中可以抽象方法,也可以有非抽象方法
2)抽象类不能创建对象
3)抽象类存在构造方法
9.抽象类成员特点?
抽象类的成员特点
成员变量:
可以是变量也可以是自定义常量
构造方法:
抽象类可以有构造方法:包括有参构造和无参构造
作用:通过抽象类多态的形式:让子类进行数据的初始化
成员方法:
可以有抽象方法,也可以有非抽象方法
抽象类的成员方法特性:
抽象方法:强制子类必须要做到一件事情:方法重写(覆盖)
非抽象方法:由继承保证可以去提高代码的复用性
10.抽象类的小问题
A:一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
只要被abstract修饰就可以定义为抽象类。作用是不能让其创建对象!
B:abstract不能和哪些关键字共存
不能和final、private、static配合使用
11.接口的概述及其特点?
接口的概念：接口体现的是一种:扩展功能
接口的特点：不能实例化(不能直接创建对象)
12.接口的成员特点?
1)接口中的成员变量都属于常量，默认修饰符：public static final
2)接口中的方法都是抽象方法，默认修饰符：public abstract
3)接口是没有构造函数的
13.抽象类和接口的区别?
1)成员的区别
成员变量：抽象类：成员变量可以是常量也可以是变量
接 口：成员变量只能是常量，默认修饰符为：public static final
构造方法：抽象类：可以有无参构造、有参构造方法
作用：通过子类进行数据初始化（通过子类创建对象）
接 口：没有构造方法
成员方法：抽象类：可以有抽象方法，也可以有非抽象方法
接 口：只能是抽象方法。默认修饰符为：public abstract
2)关系的区别
类与类的关系：extends，Java中只存在单继承，不支持多继承，但支持多层继承
类与接口：implements，一个类在继承另一个类的同时可以实现多个接口
接口与接口：继承关系，可以单继承也可以多继承
3)设计理念
抽象类：体现的是一种“is a”关系，存在继承关系
接口：体现的是“like a”关系，扩展功能