初学javaDay11

一、抽象类

1.1 概述:在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

1.2 抽象类特点:
1)一个类要被定义为抽象类,必须有关键字 :abstract
位置在类上进行修饰 : abstract class
2)什么是抽象方法?
只是给一个方法声明,不做具体体现 (就是一个方法没有方法体{})
public abstract void method(); 抽象方法
如果一个方法被abstract修饰了,那么是抽象方法,不能使用{}
3)有抽象方法的类一定要被abstract修饰,否则编译报错
4)抽象类中一定都是抽象方法吗?
错的,不一定,抽象类中可以有 抽象方法,也可以是非抽象方法;
5)抽象类不能实例化,如何创建对象呢?
可以通过抽象类的子类进行实例化
a)子类是抽象类,无意义(子类都不能实例化)
b)子类是具体类,创建对象使用多态
Animal a = new Cat() ;
6)抽象类的子类,必须重写父类中的抽象方法!
抽象类中是有构造方法的,但是不能直接实例化,需要子类进行数据初始化!

1.3 抽象类的成员特点:
成员变量
既可以是常量(需要用final进行修饰),也可以是变量
成员方法
既可以定义抽象方法,也可以定义非抽象方法;
构造方法
可以有有参,无参的构造方法,由于类抽象类,所以不能直接实例化,构造方法如何初始化?
通过子类进行数据的初始化 Animal a = new Cat() ;

1.4 抽象 abstract和哪些关键字冲突及原因
1)非法的修饰符组合:abstract和private
私有的,被私有修饰的成员方法不能被继承,而abstract修饰的方法是一个抽象的,需要子类重写方法;
2)非法的修饰符组合: abstract和static
静态和类有关系,所以这两个修饰符冲突
3)非法的修饰符组合: abstract和final
被final修饰的成员方法不能被重写
abstract修饰的成员方法需要被子类重写,冲突了!

1.5 抽象类编程题
公司很多员工，而程序员也属于员工，他有姓名，工号，工资的属性，经理也属于员工，除了上述属性外，还有奖金属性，请使用面向对象方式处理

/*
	公司很多员工，而程序员也属于员工，他有姓名，工号，工资的属性，
	经理也属于员工，除了上述属性外，还有奖金属性，请使用面向对象方式处理;
*/

//员工类
abstract class Employee{
	private String name;     //姓名
	private String id;       //工号
	private double salary;   //工资
	
	//无参构造
	public Employee(){}
	//有参构造
	public Employee(String name,String id,double 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(double salary){
		this.salary = salary;
	}
	public double getSalary(){
		return salary;
	}
	
	//抽象功能
	public abstract void work();
}

//程序员类
class Programmer extends Employee{
	public Programmer(){}
	public Programmer(String name,String id,double salary){
		super(name,id,salary);
	}
	
	public void work(){
		System.out.println("程序员需要打代码...");
	}
}

//经理类
class Manager extends Employee{
	private double bonus;    //奖金
	
	public Manager(){}
	public Manager(String name,String id,double salary,double bonus){
		super(name,id,salary);
		this.bonus = bonus;
	}
	
	//奖金
	public void setBonus(double bonus){
		this.bonus = bonus;
	}
	public double getBonus(){
		return bonus;
	}
	
	public void work(){
		System.out.println("经理需要谈项目...");
	}
}

//测试类
class AbstractDemo{
	public static void main(String[] args){
		//多态
		//程序员Programmer
		//setXXX()/getXXX()
		Employee e = new Programmer();
		e.setName("张三");
		e.setId("191501");
		e.setSalary(7000);
		System.out.println(e.getName()+" \t"+e.getId()+" \t"+e.getSalary());
		e.work();
		
		//有参构造
		e = new Programmer("李四","190516",8500);
		System.out.println(e.getName()+" \t"+e.getId()+" \t"+e.getSalary());
		e.work();
		
		System.out.println("---------------------");
		System.out.println();
		
		//经理Manager
		Employee e2 = new Manager();
		Manager m = (Manager) e2;
		m.setName("王五");
		m.setId("190247");
		m.setSalary(10000);
		m.setBonus(2000);
		System.out.println(m.getName()+" \t"+m.getId()+" \t"+m.getSalary()+" \t"+m.getBonus());
		m.work();
		
		//直接使用经理类对象访问
		Manager m2 = new Manager("赵六","190356",9500,3500);
		System.out.println(m2.getName()+" \t"+m2.getId()+" \t"+m2.getSalary()+" \t"+m2.getBonus());
		m2.work();
	}
}

二、接口

2.1 概述：体现事物的一种扩展性功能
2.2 接口特点:
1)定义接口:
格式:interface 接口名{…} 接口命名规则:和类名一样! (大驼峰命名法)
2)接口的实现类的格式:
class 子实现类名+Impl implements 接口名{}
3)接口中的方法:
只能是抽象方法
4)接口不能实例化 ,如何实例化呢?
a)如果接口的子实现(implements)类是一个抽象类,那么没有意义.
b)接口的的子实现类是一个具体类,可以接口多态的形式创建对象(实例化)
接口名 对象名 = new 子类实现类名() ;
2.3 接口的成员特点:
成员变量:
有默认修饰符:public static final
接口中的变量只能是常量
构造方法:
接口中没有构造方法
成员方法:
只能是抽象方法,默认修饰: public abstract
2.4 抽象类和接口的区别
1)成员的区别
抽象类:
成员变量:既可以使用常量,也可以使用变量
构造方法:存在,可以无参的,也可以是有参的,抽象类不能实例化,需要通过子类进行数据初始化
成员方法:
可以抽象方法,也可以非抽象方法!
接口:
成员变量:只能是常量,存在默认的修饰符public static final
构造方法:不存在
成员方法:默认修饰符 public abstract (可以不写),建议给出来
2)关系区别
类与类之间的关系:
继承关系(extends),只支持单继承,不支持多继承,但是可以多层继承
类与接口之间的关系:
实现关系(implements),一个具体类实现一个接口
Jdk—>Object类:所有类的根类,
一个类继承另一个类的同时,可以实现多个接口
接口与接口之间的关系:
继承关系(extends),单继承,支持多继承
3)设计理念:
抽象类(类与类之间的关系):体现的是"is a"的关系,A类是B类的一种/B类是A类的一种
接口(实现关系:类与接口之间的关系):体现的是一种"like a"的关系,主要描述的一种扩展功能
2.5 接口的编程题
教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识：
分析，这个案例中有哪些抽象类，哪些接口，哪些具体类，并且进行测试，代码实现

/*
	教练和运动员案例(学生分析然后讲解)
		乒乓球运动员和篮球运动员。
		乒乓球教练和篮球教练。
		为了出国交流，跟乒乓球相关的人员都需要学习英语。
		请用所学知识：
		分析，这个案例中有哪些抽象类，哪些接口，哪些具体类，并且进行测试，代码实现
		
	分析：
		运动员类(sportsman)
			成员变量：姓名、年龄
			成员方法：setXXX()/getXXX()
					play()
					study() 特有功能
			构造方法：无参构造/有参构造
		教练类(coach)
			成员变量：姓名、年龄
			成员方法：setXXX()/getXXX()
					play()
					teach() 特有功能
			构造方法：无参构造/有参构造
			
		将共性内容抽取----->Person类  ----->抽象类
				将play功能抽象
				playPingPong()   打乒乓球
				playBasketball() 打篮球
				
		接口:学习英语	额外的功能(扩展功能)
			studyEnglish(); 抽象功能
*/

//定义接口
interface English{
	public abstract void studyEnglish(); //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 play();
}

//运动员类
class Sportsman extends Person{
	public Sportsman(){}
	public Sportsman(String name,int age){
		super(name,age);
	}
	
	public void play(){
		System.out.println("运动员训练打球");
	}
}

//教练类
class Coach extends Person{
	public Coach(){}
	public Coach(String name,int age){
		super(name,age);
	}
	
	public void play(){
		System.out.println("教练教运动员打球");
	}
}

//跟乒乓球相关的人员都需要学习英语
//乒乓球运动员
class PingPongSportsman extends Sportsman implements English{
	public PingPongSportsman(){}
	public PingPongSportsman(String name,int age){
		super(name,age);
	}
	
	public void studyEnglish(){
		System.out.println("通过学习,乒乓球运动员学会了说英语");
	}
}

//乒乓球教练
class PingPongCoach extends Coach implements English{
	public PingPongCoach(){}
	public PingPongCoach(String name,int age){
		super(name,age);
	}
	
	public void studyEnglish(){
		System.out.println("通过学习,乒乓球教练学会了说英语");
	}
}

//篮球运动员
class BasketballSportsman extends Sportsman{
	public BasketballSportsman(){}
	public BasketballSportsman(String name,int age){
		super(name,age);
	}
}

//篮球教练
class BasketballCoach extends Coach{
	public BasketballCoach(){}
	public BasketballCoach(String name,int age){
		super(name,age);
	}
}

//测试类
class InterfaceDemo{
	public static void main(String[] args){
		//乒乓球
		//乒乓球运动员
		//setXXX()/getXXX()
		PingPongSportsman ppsm = new PingPongSportsman();
		ppsm.setName("张继科");
		ppsm.setAge(32);
		System.out.println(ppsm.getName()+" \t"+ppsm.getAge());
		ppsm.play();
		ppsm.studyEnglish();
		
		System.out.println("---------------------");
		System.out.println();
		
		//乒乓球教练
		//有参构造
		PingPongCoach ppc = new PingPongCoach("刘国梁",44);
		System.out.println(ppc.getName()+" \t"+ppc.getAge());
		ppc.play();
		ppc.studyEnglish();
		
		System.out.println("---------------------");
		System.out.println();
		
		//篮球
		//篮球教练
		//setXXX()/getXXX()
		BasketballCoach bc = new BasketballCoach();
		bc.setName("李楠");
		bc.setAge(46);
		System.out.println(bc.getName()+" \t"+bc.getAge());
		bc.play();
		
		System.out.println("---------------------");
		System.out.println();	
		
		//篮球运动员
		//有参构造
		BasketballSportsman bsm = new BasketballSportsman("姚明",40);
		System.out.println(bsm.getName()+" \t"+bsm.getAge());
		bsm.play();
		
		System.out.println("---------------------");
		System.out.println();	
		
		//直接使用运动员类对象访问
		Sportsman sm = new Sportsman("易建联",33);
		System.out.println(sm.getName()+" \t"+sm.getAge());
		sm.play();
	}
}

初学java，文章中若有什么不对的，欢迎各位大佬留言指出~