【Java作业】2017.10.21 / 10.22

作业一

/*
	乒乓球运动员和篮球运动员。
    乒乓球教练和篮球教练。
    为了出国交流，跟乒乓球相关的人员都需要学习英语(接口实现)
*/

 //测试类
 public class TestDemo {
	public static void main(String[] args) {
		EnglishPingpongAthlete epa=new EnglishPingpongAthlete("萨内蒂",43);
		System.out.println(epa.getName()+"，"+epa.getAge());
		epa.eat();
		epa.studyEnglish();
		
		System.out.println("----------------------");
		
		EnglishPingpongCoach epc=new EnglishPingpongCoach("伊布拉希莫维奇",35);
		System.out.println(epc.getName()+"，"+epc.getAge());
		epc.eat();
		epc.studyEnglish();
	}
}

//运动员类（抽象类）
abstract class Athlete {
	private String name;
	private int age;
	
	//有参构造
	public Athlete(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	//无参构造
	public Athlete() {
		super();
	}
	
	//set,get方法
	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("吃喝");
	}
	public void match() {
		System.out.println("参加比赛");
	}
}

//教练类（抽象类）
abstract class Coach {
	private String name;
	private int age;
	
	public Coach() {
		super();
	}
	
	public Coach(String name, int age) {
		super();
		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("吃喝");
	}
	public void teach() {
		System.out.println("教运动员");
	}
}

//乒乓球运动员（继承运动员类）
class PingpongAthlete extends Athlete{
	
	public PingpongAthlete() {
		super();
	}

	public PingpongAthlete(String name, int age) {
		super(name, age);
	}
	
	public void eat() {
		System.out.println("吃喝");
	}
	public void match() {
		System.out.println("参加乒乓球比赛");
	}
}

//篮球运动员（继承运动员类）
class BasketballAthlete extends Athlete {

	public BasketballAthlete() {
		super();
	}

	public BasketballAthlete(String name, int age) {
		super(name, age);
	}
	
	public void eat() {
		System.out.println("吃喝");
	}
	public void match() {
		System.out.println("参加篮球比赛");
	}
}

//乒乓球教练员（继承教练员）
class PingpongCoach extends Coach{

	public PingpongCoach() {
		super();
	}

	public PingpongCoach(String name, int age) {
		super(name, age);
	}
	
	public void eat() {
		System.out.println("吃喝");
	} 
	public void teach() {
		System.out.println("教乒乓球运动员参加比赛");
	}	
}

//篮球教练员（继承教练员）
class BasketballCoach extends Coach {

	public BasketballCoach() {
		super();
	}

	public BasketballCoach(String name, int age) {
		super(name, age);
	}
	
	public void eat() {
		System.out.println("吃喝");
	}
	public void teach() {
		System.out.println("教篮球运动员参加篮球比赛");
	}
}

//讲英语（接口）
interface StudyEnglish {
	public  abstract void studyEnglish();
}

//讲英语的乒乓球运动员（继承乒乓球运动员并且实现讲英语的接口）
class EnglishPingpongAthlete extends PingpongAthlete implements StudyEnglish {
	
	
	public EnglishPingpongAthlete() {
		super();
	}

	public EnglishPingpongAthlete(String name, int age) {
		super(name, age);
	}
	
	public void eat() {
		System.out.println("吃喝");
	}
	//接口方法
	public void studyEnglish() {
		System.out.println("胖胖球运动员学习英语出国交流");
	}
}

//讲英语的乒乓球教练员（继承乒乓球教练员并且实现讲英语的接口）
class EnglishPingpongCoach extends PingpongCoach implements StudyEnglish {

	public EnglishPingpongCoach() {
		super();
	}

	public EnglishPingpongCoach(String name, int age) {
		super(name, age);
	}
	
	public void eat() {
		System.out.println("吃喝");
	}
	
	//接口方法
	public void studyEnglish() {
		System.out.println("胖胖球教练员学习英语出国交流");
	}
}

结果： 萨内蒂，43
吃喝
胖胖球运动员学习英语出国交流
----------------------
伊布拉希莫维奇，35
吃喝
胖胖球教练员学习英语出国交流 

2.final关键字可以干什么?有什么特点?

final可以修饰变量，成员方法和类

（1）修饰类，则该类不能被继承

（2）修饰成员方法，则该方法不能被重写

（3）修饰基本数据类型变量，则该变量不能再被更改

3.final关键字的面试题?     A:修饰局部变量 B:初始化时机

（1）final修饰局部变量：
  基本数据类型：如果局部变量是一个基本数据类型,那么被final修饰,基本数据类型的变量的值不能再改变
  引用数据类型：如果用final修饰引用类型的变量,那么它不能在重写分配堆内存空间,但是可以改变可以成员变量的值

（2）初始化时机：

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

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

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

注：只可选择一种方法

4.多态是什么？前提？

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

前提：（1）必须有继承关系

（2）必须有方法重写

（3）有父类引用指向子类对象（向上转型）

5.多态中成员访问的特点？

（1）成员变量：编译看左，运行看左

（2）成员方法（非静态）：编译看左，运行看右

注：由于存在方法重写，故运行的是子类的成员方法

（3）成员方法（静态static）：编译看左，运行看左

注：静态方法算不上方法重写，静态方法直接跟类有关！！！

（4）构造方法：还是对象进行初始化，由于是一种继承关系，还是分层初始化

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

好处：

（1）提高了代码的维护性（继承保证）

（2）提高了代码的扩展性（多态保证）

弊端：

不能访问子类的特有方法

解决方法：

（1）创建子类具体对象（问题：会产生内存溢出现象）

（2）父类的引用强制转换为子类的引用（向下转型）

注：向下转型必须依赖于向上转型

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

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

向下转型：父类引用强制转换为子类引用

8.抽象类概述及其特点

概念：每一个类的方法的功能不一样，故不能定义为一个具体类，而是给出一个声明（abstract）

特点：当一个类中存在抽象功能（方法）时，则这个类一定要定义为抽象类

一个类中既可以有抽象方法，也可以存在非抽象方法

抽象类实例化的方式：抽象类多态形式（父类引用指向子类对象，通过子类来进行初始化）

9.抽象类成员特点

抽象类的成员特点：

（1）成员变量：可以是变量，也可以是自定义常量

（2）构造方法：可以有构造方法，有参、无参均可

（3）成员方法：可以有抽象方法，也可以存在非抽象方法

抽象类的成员方法特性：

（1）抽象方法：强制子类必须做到方法重写

（2）非抽象方法：由继承保证可以提高代码的复用性

10.抽象类问题。一个类如果没有抽象方法，可不可以定义为抽象类？若可以有什么意义？abstract不能和那些关键字共存？

可以。

abstract不能和 static， final 和 private 共存

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

接口所体现出的是一种“扩展功能”

接口特点：不能实例化（创建对象）

12.接口的成员特点

（1）成员变量：只能为常量，并且默认被 “public static final” 修饰

（2）构造方法：接口不存在构造方法！

（3）成员方法：接口中成员方法默认被 “public abstract” 修饰

13.抽象类和接口的区别

（1）成员的区别：

①成员变量：

抽象类：成员变量可以是常量，也可以是变量

接口：成员变量只可为常量，默认被：public static final 修饰

②构造方法：

抽象类：可以有有参和无参构造方法

接口：不存在构造方法

③成员方法的区别：

抽象类：可以由抽象方法，也可以有非抽象方法

接口：只能为抽象方法，且默认被： public abstract 修饰

（2）关系的区别：

①类与类的关系：

继承关系：extends，只可单继承不可多继承，但可多层继承

②类与接口的关系：

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

③接口与接口的关系：

继承关系：extends，可以单继承，也可以多继承

（3）设计理念的区别：

①抽象类：体现的是一种 “is a” 的关系，存在继承关系

②接口：体现到是一种 “like a” 的关系，接口所体现的是一种扩展功能

14.形式参数和返回值问题
形式参数
基本类型：需要什么类型，就传什么类型
引用类型：

1）具体类：若形式参数是一个具体的类，则需要创建该类的对象

2）抽象类：若形式参数为抽象类，则需新定义一个抽象类的子类来进行实例化（抽象类多态）

3）接   口：若形式参数为接口，那需新定义一个接口的子实现类，通过接口多态来进行实例化

返回值类型
引用类型：

1）具体类：直接返回该类对象（通常开发中使用匿名对象）

2）抽象类：返回值若为抽象类，则需返回该抽象类的子类对象

3）接   口：返回值若是接口类型，需返回该接口的子实现类对象

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

概述：

在一个类中定义另一个类，那么则为内部类

访问特点：

内部类可以访问外部类的成员，包括私有

    外部类想要访问内部类的成员，必须通过创建内部类的对象访问该内部类的成员

16.内部类的分类

（1）成员内部类：在外部类的成员位置

（2）局部内部类：在外部类的局部位置定义的这个类

17.匿名内部类

（1）前提：必须存在一个接口或者一个类（具体或抽象均可）

（2）格式： new 接口名 / 类名（）｛

方法重写；

｝

（3）当在接口中存在多个方法时：

接口名  对象名 = new  接口名（）｛

方法重写；

｝；

对象名.方法名（）；访问