day11接口

对接口的理解是值对类的功能进行扩展和补充,当我们对接口进行设置的时候,可操作性是很广泛的.对一个类可以扩展许多个接口,实现许多的功能.
1:多态中什么是向上转型？什么是向下转型？
向上:
在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法
向下:与向上转型相对应的就是向下转型了。向下转型是把父类对象转为子类对象
2:抽象类概述及其特点?
将当前功能定义抽象功能,并且一个类中有抽象功能,那么这个类要被定义为抽象类!
抽象类的特点:
1)一个类要被定义为抽象类,必须有关键字 :abstract
位置在类上进行修饰 : abstract class
2)什么抽象方法?
只是给一个方法声明,不做具体体现 (就是一个方法没有方法体{})
public abstract void method(); 抽象方法
如果一个方法被abstract修饰了,那么是抽象方法,不能使用{}
3)有抽象方法的类一定要被abstract修饰,否则编译报错

		4)抽象类中一定都是抽象方法吗?
			错的,不一定,抽象类中可以有 抽象方法,也可以是非抽象方法;
			
		5)抽象类不能实例化,如何创建对象呢?
			可以通过抽象类的子类进行实例化
			a)子类是抽象类,无意义(子类都不能实例化)
			b)子类是具体类,创建对象使用多态
				Animal a = new Cat() ;
			
		6)抽象类的子类,必须重写父类中的抽象方法!
				
			抽象类中是有构造方法的,但是不能直接实例化,需要子类进行数据初始化!

3:抽象类成员特点?
成员变量
既可以是常量(需要用final进行修饰),也可以是变量
成员方法
既可以定义抽象方法,也可以定义非抽象方法;
构造方法
可以有有参,无参的构造方法,由于类抽象类,所以不能直接实例化,构造方法如何初始化?
通过子类进行数据的初始化 Animal a = new Cat() ;
4:抽象类编程题
公司很多员工，而程序员也属于员工，他有姓名，工号，工资的属性，
经理也属于员工，除了上述属性外，还有奖金属性，请使用面向对象方式处理;
abstract class Employee{
//定义成员变量
private String name;
private String id;
private int salary;
//无参构造
public Employee(){};
//有参构造
public Employee(String name,String id,int salary){
this.name = name;
this.id = id;
this.salary = salary;
}
//提供setXXX,getXXX方法
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setId(String id){
this.id = id;
}
public String getId(){
return id;
}
public void setSalary(int salary){
this.salary = salary;
}
public int getSalary(){
return salary;
}
public abstract void work();
}

class Programmer extends Employee {
//给出无参
public Programmer(){};
//有参
public Programmer(String name,String id,int salary){
super(name,id,salary);

}
//抽象功能
public void work(){
	System.out.println("程序员没日没夜的脱发");
	}

}

class Manager extends Employee{
private int bonus;
//无参
public Manager(){}
//有参
public Manager(String name,String id,int salary){
super(name,id,salary);
}
//特有功能
public void setBonus(int bonus){
this.bonus = bonus;
}
public int getBonus(){
return bonus;
}
//抽象功能
public void work(){
System.out.println(“经理没日没夜的喝酒还是脱发”);
}
}
class AbstractTest1{
public static void main(String[] args){
Employee p = new Programmer();
p.setName(“王昭君”);
p.setId(“1881”);
p.setSalary(7885);
System.out.print(p.getName() +"—"+p.getId()+"----"+p.getSalary());
p.work();
System.out.println("---------");
Employee p1 = new Programmer(“西施”,“7984”,5529);
System.out.print(p1.getName() +"—"+p1.getId()+"----"+p1.getSalary());
p1.work();
System.out.println("---------");

	Manager m = new Manager();
	m.setName("武则天");
	m.setId("5475");
	m.setSalary(47457);
	m.setBonus(5405);
	System.out.print(m.getName() +"---"+m.getId()+"----"+m.getSalary()+"---"+m.getBonus());
	m.work();
    
	System.out.println("------------") ;
	
	Manager m2 = new Manager("狄仁杰","007",7000) ;
	m2.setBonus(54547);
	System.out.print(m2.getName()+"---"+m2.getId()+"----"+m2.getSalary());
	System.out.println(m2.getBonus());
	m2.work();
	
	//多态调用,向下转型
	
	Employee m3 = new Manager();
	m3.setName("武则天");
	m3.setId("5475");
	m3.setSalary(47457);
	Manager m4 = (Manager)m3;
	m4.setBonus(4562);
	System.out.println(m3.getName()+"---"+m3.getId()+"----"+m3.getSalary()+"---"+m4.getBonus());
	m3.work();
	
}

}

5:抽象 abstract和哪些关键字冲突，为什么？

private:私有的,被私有修饰的成员方法不能被继承,而abstract修饰的方法是一个抽象的,需要子类重写方法;

非法的修饰符组合: abstract和static
	静态和类有关系   ,所以这两个修饰符冲突
	
非法的修饰符组合: abstract和final
	被final修饰的成员方法不能被重写
	abstract修饰的成员方法需要被子类重写,冲突了!

6:接口的概述及其特点?
概述:体现事物的一种扩展性功能
7:接口的成员特点?
接口特点:
1)定义接口:
格式:interface 接口名{…} 接口命名规则:和类名一样! (大驼峰命名法)
2)接口的实现类的格式:
class 子实现类名+Impl implements 接口名{}
3)接口中的方法:
只能是抽象方法
4)接口不能实例化 ,如何实例化呢?
a)如果接口的子实现(implements)类是一个抽象类,那么没有意义.
b)接口的的子实现类是一个具体类,可以接口多态的形式创建对象(实例化)
接口名 对象名 = new 子类实现类名() ;

8:抽象类和接口的区别?
抽象类和接口之间的区别?
1)成员的区别
抽象类:
成员变量:既可以使用常量,也可以使用变量
构造方法:存在,可以无参的,也可以是有参的,抽象类不能实例化,需要通过子类进行数据初始化
成员方法:
可以抽象方法,也可以非抽象方法!
接口:
成员变量:只能是常量,存在默认的修饰符public static final
构造方法:不存在
成员方法:默认修饰符 public abstract (可以不写),建议给出来
2)关系区别
类与类之间的关系:
继承关系(extends),只支持单继承,不支持多继承,但是可以多层继承
类与接口之间的关系:
实现关系(implements),一个具体类实现一个接口
Jdk—>Object类:所有类的根类,
一个类继承另一个类的同时,可以实现多个接口
接口与接口之间的关系:
继承关系(extends),单继承,支持多继承
3)设计理念:
抽象类(类与类之间的关系):体现的是"is a"的关系,A类是B类的一种/B类是A类的一种
接口(实现关系:类与接口之间的关系):体现的是一种"like a"的关系,主要描述的一种扩展功能
9:接口的编程题
第一题：
教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类，并且进行测试，代码实现
interface English{
void english();
}
//定义父类
abstract class Person{
private String name;
private int age;
//无参
public Person(){}
public Person(String name,int age){
this.name = name;
this.age = age;
}
//有参
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return age;
}
public abstract void sport();
}

//运动员
class Sportsman extends Person{
public Sportsman(){}
public Sportsman(String name,int age){
super(name,age);
}
public void sport(){
System.out.println(“运动员整天在运动”);
}
public void game(){
System.out.println(“运动员偶尔打游戏”);
}

}
//出国运动员
class OutSportsman extends Sportsman implements English{
public OutSportsman(){}
public OutSportsman(String name,int age){
super(name,age);
}
public void english(){
System.out.println(“出国运动员会英语了”);
}
}
//教练
class Coach extends Person{
public Coach(){}
public Coach(String name,int age){
super(name,age);
}
public void sport(){
System.out.println(“教练偶尔运动一下”);
}
public void majiang(){
System.out.println(“教练偶尔打打麻将”);
}
}
//出国教练
class OutCoach extends Coach implements English{
public OutCoach(){}
public OutCoach(String name,int age){
super(name,age);
}
public void english(){
System.out.println(“出国教练会英语了”);
}
}
//测试
class InterfaceTest1{
public static void main(String[] args){
OutSportsman os = new OutSportsman();
os.setName(“马龙”);
os.setAge(25);
System.out.println(os.getName()+"----"+os.getAge());
os.sport();
os.game();
os.english();

	System.out.println("-----------------------");
	
	os = new OutSportsman("马龙",25);
	System.out.println(os.getName()+"----"+os.getAge());
	os.sport();
	os.game();
	os.english();
}

}

第二题
	猫和狗都属于动物，他们都有吃饭和睡觉的功能，但是具体吃饭和睡觉也是不一样的，
	并且同时部分猫和狗有跳高的功能，请使用你掌握所学的知识进行分析存在哪些类，
							哪些接口，哪些是抽象类并且代码实现
							interface AnimalTrain{
 void jump() ;

}

abstract class Animal{
public abstract void sleep();
public abstract void eat();
}

class Cat extends Animal{
public void sleep(){
System.out.println(“猫都是白天睡觉”);
}
public void eat(){
System.out.println(“猫吃鱼”);
}
}
class Dog extends Animal{
public void sleep(){
System.out.println(“狗都是晚上睡觉”);
}
public void eat(){
System.out.println(“狗吃肉”);
}
}
class JumpCat extends Cat implements AnimalTrain{
public void jump(){
System.out.println(“有部分的猫是会跳的”);
}
}
class JumpDog extends Dog implements AnimalTrain{
public void jump(){
System.out.println(“有部分的狗是会跳的”);
}
}
class InterfaceTest2{
public static void main(String[] args){
JumpCat jc = new JumpCat();
jc.sleep();
jc.eat();
jc.jump();
JumpDog jd = new JumpDog();
jd.sleep();
jd.eat();
jd.jump();
}
}