Java入门Day011（继承 抽象 接口）

1:多态中什么是向上转型？什么是向下转型？

向上转型：
Fu f = new Zi();
向下转型：
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的
总的来说，向上转型总是安全的，向下转型则未必，可能会发ClassCastException.

2:抽象类概述及其特点?

抽象类：abstract关键字，用于修饰方法和类，有抽象方法的类必须是抽象类
注意：如果一个类继承了抽象类，需要重写它所有的抽象方法，或者将这个类也修饰成抽象类。、
抽象类特点
a.抽象方法只能在抽象类里面。
b.抽象类和抽象方法必须被abstract修饰。
c.抽象类不能创建对象（即不能实例化）。
d.抽象类中可以有非抽象方法。
e.抽象类和类的关系也是继承。
f.如果一个类继承了抽象类，要么重写所有抽象方法，要么自己也成为抽象类。

3:抽象类成员特点?

抽象类的成员特点
成员变量：可以有成员变量也可以有常量
成员方法：可以有抽象方法也可以有非抽象方法
构造方法：可以有构造方法，需要对抽象类的成员变量进行初始化

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) ;
	}
	
	//work
	public void work(){
		System.out.println("程序员没日没夜的coding...") ;
	}
}
//经理类
class Manager extends Employee{
	//特有属性 
	private int bonus ;//奖金属性
	
	public Manager(){}
	public Manager(String name,String id,int salary,int bonus){
		super(name,id,salary) ;
		this.bonus = bonus; //成员变量隐藏局部变量
	}
	
	public void setBonus(int bonus){
		this.bonus = bonus ;
	}
	public int getBonus(){
		return bonus;
	}
	
	//work
	public void work(){
		System.out.println("经理没日没夜的跟甲方喝酒谈项目...") ;
	}
}

//测试类
class AbstractTest3{
	public static void main(String[] args){
		//测试程序员
		//多态
		Employee em = new Programmer() ; //抽象类多态
		em.setName("cong") ;
		em.setId("1000");
		em.setSalary(8000) ;
		System.out.println(em.getName()+"---"+em.getId()+"----"+em.getSalary());
		em.work() ;
		//有参构造
		em = new Programmer("张","1111",8000) ;
		System.out.println(em.getName()+"---"+em.getId()+"----"+em.getSalary());

		em.work() ;
		//经理类
		//em = new Manager() ;
		//因为奖金属性是经理特有属性,直接使用经理类对象访问
		Manager m = new Manager() ;
		m.setName("gao") ;
		m.setId("007") ;
		m.setSalary(12000) ;
		m.setBonus(8000) ;
		System.out.println(m.getName()+"---"+m.getId()+"----"+m.getSalary()+"---"+m.getBonus());
		m.work();
		Manager m2 = new Manager("秋香","008",7000,8000) ;
		System.out.println(m2.getName()+"---"+m2.getId()+"----"+m2.getSalary()+"---"+m2.getBonus());
		m2.work();
		
	}
}

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

abstract::表明希望被重写，即该类中的方法被继承后需要重写。
1.private
被private修饰的方法，子类不能继承到，故不能重写，也就不能共存
2.final
final修饰的类不能被继承，方法不能被重写，变量不能更改值，故不能共存
3.static
static能被实例化直接调用，即不需要依赖对象就可进行访问，而abstract不能被实例化，故不能共存

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

从狭义的角度讲就是指java中的interface
从广义的角度讲对外提供规则的都是接口
接口特点：
1、接口中定义的全都是抽象方法。
2、接口用关键字interface表示。即interface 接口名 { }
3、类实现接口用implements表示。即class 类名 implements 接口名 { }
4、接口不能实例化。
　那么，接口如何实例化呢？按照多态的方式来实例化。
接口的子类
　　可以是抽象类，但是意义不大。
　　可以是具体类，要重写接口中所有的抽象方法。（推荐方案）

7:接口的成员特点?

接口的成员特点:
成员变量:
有默认修饰符:public static final
接口中的变量只能是常量
构造方法:
接口中没有构造方法
成员方法:
只能是抽象方法,默认修饰:public abstract

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{
	public abstract void speak();
}

abstract class Person{
	private String name;
	private int age;
	//无参构造
	public Person() {}
	//有参构造
	public Person(String name,int age) {
		this.age=age;
		this.name=name;
	}
	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 eat();
	public void sleep() {
		System.out .println("人都要睡觉");
	}
}
class Player extends Person{
	public Player() {super();}
	public Player(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("player eats....");	
	}
	public  void stu() {
		System.out.println("player....");
	}
}
class Coach extends Person{
	public Coach() {}
	public Coach(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("coach eats....");	
	}
	public  void coa() {
		System.out.println("coach....");
	}
}
class PingpangPlayer extends Player implements English{
	public PingpangPlayer() {}
	public PingpangPlayer(String name,int age) {
		super(name,age);
	}
	public void speak() {
		System.out.println("pingp player studies English....");
	}
	public void eat() {
		System.out.println("pingp player eats food... ");
	}
}
class PingpangCoach extends Coach implements English{
	public PingpangCoach() {}
	public PingpangCoach(String name,int age) {
		super(name,age);
	}
	public void speak() {
		System.out.println("pingp coach studies English....");
	}
	public void eat() {
		System.out.println("pingp coach eats food... ");
	}
}
class BasketballPlayer extends Player{
	public BasketballPlayer() {}
	public BasketballPlayer(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("bsk Player eats food... ");
	}
}
class BasketballCoach extends Coach{
	public BasketballCoach() {}
	public BasketballCoach(String name,int age) {
		super(name,age);
	}
	public void eat() {
		System.out.println("bsk coach eats food... ");
	}
}

class test{
	public static void main(String[] args) {
		PingpangPlayer p1=new PingpangPlayer();
		p1.eat();
		p1.sleep();
		p1.speak();
		PingpangCoach p2=new PingpangCoach();
		p2.eat();
		p2.sleep();
		p1.speak();
		BasketballPlayer b1=new BasketballPlayer();
		b1.eat();
		b1.sleep();
		BasketballCoach b2=new BasketballCoach();
		b2.eat();
		b2.sleep();
		//多态
		Person p=new Player();
		Player pp=(Player)p;
		pp.stu();
	}
		
	}

第二题

  猫和狗都属于动物，他们都有吃饭和睡觉的功能，但是具体吃饭和睡觉也是不一样的，并且同时部分猫和狗有跳高的功能，请使用你掌握所学的知识进行分析存在哪些类，哪些接口，哪些是抽象类并且代码实现
  定义一个跳高接口。再定义两个类：跳高猫，继承猫，实现猫的跳高接口；跳高狗，继承狗，实现狗的跳高接口。

abstract class Animal {
    private String name;                //姓名
    private int age;                    //年龄

    public Animal() {}                  //空参构造

    public Animal(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 eat();         //吃饭

    public abstract void sleep();       //睡觉
}

interface Jumping {                     //跳高的接口
    public void jump();
}

class Cat extends Animal {
    public Cat() {}                 //空参构造

    public Cat(String name,int age) {//有参构造
        super(name,age);
    }

    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void sleep() {
        System.out.println("侧着睡");
    }
}

class JumpCat extends Cat implements Jumping {
    public JumpCat() {}                 //空参构造

    public JumpCat(String name,int age) {//有参构造
        super(name,age);
    }

    public void jump() {
        System.out.println("猫跳高");
    }
}
class test {
    public static void main(String[] args) {
        Cat c = new Cat("加菲",8);
        c.eat();
        c.sleep();

        JumpCat jc = new JumpCat("跳高猫",3);
        jc.eat();
        jc.sleep();
        jc.jump();
    }
}

第三题

/*
	老师和学生案例,加入抽烟的额外功能

	分析:
		从具体到抽象
	Teacher类
		成员变量:姓名,年龄
		成员方法:setXXX()getXXX()
				eat(){}
				smoke{}
				teach(){} 特有功能
		构造方法:无参构造/有参构造
		
	Student类
		成员变量:姓名,年龄
		成员方法:setXXX()getXXX()
				eat(){}
				smoke{}
				study(){} 特有功能
		构造方法:无参构造/有参构造
		
		将共性内容抽取----->Person类  ----->抽象类
				将eat功能抽象,
		
		抽烟的老师---->属于老师的一种
		抽烟的学生---->属于学生的一种
		
		接口:抽烟	额外的功能(扩展功能)
			smoking() ;抽象功能
			
实现:
	从抽象到具体	
		接口
		抽象类Person
			Teacher
				SmokeTeacher
			Student
				SmokeStudent
					
*/
//定义一个接口
interface Smoke{
	//抽象方法
	 void smoking() ;//隐藏默认修饰符public abstract
}
//抽象类:人类
abstract class Person{
	private String name ;//姓名
	private int age ; //年龄
	public Person(){}
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	
	//公共setxxx()/getXXX()
	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 eat() ;
}
//定义一个老师类
class Teacher extends Person{
	public Teacher(){}
	public Teacher(String name,int age){
		super(name,age) ;
	}
	
	//重写eat()
	public void eat(){
		System.out.println("老师喝小米稀饭...") ;
	}
	
	public void teach(){
		System.out.println("老师教学生学习JavaEE...");
	}
}
//部分老师抽烟
class SmokeTeacher extends Teacher implements Smoke{
	public SmokeTeacher(){}
	public SmokeTeacher(String name,int age){
		super(name,age) ;
	}
	//经过学习,会抽烟了
	public void smoking(){
		System.out.println("老师会抽烟了...");
	}
	
}

//抽烟的学生自己测试

//测试类
class InterfaceTest{
	public static void main(String[] args){
	/*
		继承中关系:
			子类的构造方法(无参/有参),默认父类的无参构造方法,一定要保证子类中的构造方法中的一个要访问父类的无参
	*/
	
		//测试:创建具体类对象
		SmokeTeacher st = new SmokeTeacher() ;
		st.setName("高圆圆");
		st.setAge(39);
		System.out.println(st.getName()+"----"+st.getAge());
		st.eat();
		st.teach();
		st.smoking();
		
		System.out.println("-----------------------");
		//有参赋值
		st = new SmokeTeacher("赵又廷",42) ;
		System.out.println(st.getName()+"----"+st.getAge());
		st.eat();
		st.teach();
		st.smoking();
		 
	}
}