了解Java程序之面向对象

面向对象

抽象类:
概念:
针对一个事物,如果这个事物并不是具体事物,而是概括性的(需要抽象修饰这个类),比如动物,应该定义不应该定义具体类class Animal{},并且动物的eat()/sleep()每个具体动物吃和睡不同的,所以这些功能应该声明(方法不能方法主体)将当前这个类定义为抽象类!
格式:
关键字:abstract ;

abstract class 类名{}	

抽象方法
只给方法定义一个方法声明,没有方法主体
权限修饰符 返回值类型 方法名 ();
抽象类的特点:
抽象类不能被实例化;
父类强制子类完成的事情;
抽象类的成员特点:
成员变量:既可以是常量,也可以是变量;
成员方法:既可以是抽象的也可以是非抽象的;(如果一个类中没有抽象方法也可以将这个类定义为抽象类)
构造方法:抽象类中可以有无参构造方法和有参构造方法;
注意事项
1)如果一个类中有抽象方法,那么这个类一定是抽象类
2)抽象类中不一定都是抽象方法,可以是非抽象的也可以是抽象的
3)抽象类的子类是具体类:采用父类引用指向子类
跟abstract冲突的关键字
private:私有的,外界不能访问的,被private修饰的方法不能被继承
final :状态修饰符 被final修饰的成员方法,不能被重写,而抽象类中的抽象方法必须让子类重写这个功能!
static:静态,跟类相关,静态的成员方法,算不上方法重写,能够被static修饰,想通过类名调用

//父类(员工类)
abstract class Staff{
	//成员变量
	private String name;
	private int empId;
	private int salary;
	//构造方法
	public Staff(){}
	public Staff(String name,int empId,int salary){
		this.name=name;
		this.empId=empId;
		this.salary=salary;
	}
	//setxxx()/getxxx()
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setEmpId(int empId){
		this.empId=empId;
	}
	public int getEmpId(){
		return empId;
	}
	public void setSalary(int salary){
		this.salary=salary;
	}
	public int getSalary(){
		return salary;
	}
	//抽象方法
	public abstract void work();
	public abstract void smoke();
}
//子类1(程序员类)
class Programmer extends Staff{
	public Programmer(){}
	public Programmer(String name,int empId,int salary){
		//	调用父类的有参构造
		super(name,empId,salary);
	}
	public void work(){
		System.out.println("改bug!");
	}
	public void smoke(){
		System.out.println("抽南京!");
	}
}
//子类2(经理类)
class Manager extends Staff{
	private int bonus;
	public Manager(){}
	public Manager(String name,int empId,int salary){
		super(name,empId,salary);
		this.bonus=bonus;
	}
	public void setBonus( int bonus){
		this.bonus=bonus;
	}
	public int getBonus(){
		return bonus;
	}
	public void work(){
		System.out.println("和客户交谈!");
	}
	public void smoke(){
		System.out.println("抽中华!");
	}
}
//测试类
class AbstractTest2{
	public static void main(String[] args){
			Staff s = new Programmer("张三",0124,12312);
			System.out.println("姓名:"+s.getName()+",工号:"+s.getEmpId()+",工资:"+s.getSalary());
			s.work();
			s.smoke();
			Staff s2=new Manager("李四",0123,23155);
			Manager m=(Manager)s2;
			m.setBonus(7900);
			System.out.println("姓名:"+s2.getName()+",工号:"+s2.getEmpId()+",工资:"+s2.getSalary()+",奖金:"+m.getBonus());
			s2.work();
			s2.smoke();
	}
}

接口
概念:
体现一种事物的扩展性
格式:
interface 接口名{}
接口名和类名定义规则一致
接口中的方法是抽象方法
注意事项:
1)接口不能实例化;
2)接口的子实现类:关键字 implements 实现的关系
当接口的子实现类是抽象类的情况下: 子类抽象的;无法实例化,无意义;
当接口的子实现类是具体类的情况下:接口多态实例化;通过子类实例化;
格式: 接口名 对象名=new 子实现类类名();
接口中的成员特点
成员变量:
存在默认的修饰符 public static final ,接口变量只能是常量!
被静态修饰的成员变量: 可以被类名或者是接口名访问
构造方法:
没有构造方法
成员方法:
接口的方法是抽象方法,存在默认修饰符 public abstract
抽象类和接口的区别
1)成员的区别
抽象类
成员变量:
既可以是常量,也可以是变量 !
构造方法：有，无参构造/有参构造方法 ,作用:通过具体的子类进行实例化!(对对象的数据初始化)
成员方法:
既可以是抽象的,也可以是非抽象的,
如果抽象的成员方法,必须携带public abstract 声明
接口
成员变量：
只能是常量： 存在默认的修饰符 ：public static final
构造方法:不存在
成员方法: 存在默认修饰符
public abstract 可以省略不写! (建议刚开始写接口中的方法,带上修饰符)
2)关系的区别
类与类的关系: (类可以是抽象类)
extends 继承关系, 只支持单继承,不支持多继承,但是多层继承!
类与接口的关系:
implements 实现关系 并且一个类继承自另一个类的同时,可以实现多个接口 (Java底层源码中很多都是)
接口与接口的关系:
extends 继承关系: 可以单继承,也可以多继承! (多继承技术仅限于Java中接口)
3)设计理念的区别
抽象类多态进行对象的创建, 体现的也是一种"is a"的关系
接口的实例化,需要通过子实现类实例化, (implements),体现的是一种"like a" 的关系

//接口
interface AnimalTrain{
	public abstract void jump();
}
//抽象类  爷爷类
abstract class Animal{
	private String name;
	private String color;
	private int age;
	public Animal(){}
	public Animal(String name,int age,String color){
		this.name=name;
		this.age=age;
		this.color=color;	 
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public String getColor(){
		return color;
	}
	public abstract void eat();
	public abstract void sleep();
}
//猫类  父类
class Cat extends Animal{
	public Cat(){}
	public Cat(String name,int age,String color){
		super(name,age,color);
	}
	public void eat(){
		System.out.println("猫吃鱼!");
	}
	public void sleep(){
		System.out.println("猫躺着睡觉!");
	}
	public void play(){
		System.out.println("猫会玩老鼠!");
	}
}
//狗类  父类
class Dog extends Animal{
	public Dog(){}
	public Dog(String name,int age,String color){
		super(name,age,color);
	}
	public void eat(){
		System.out.println("狗吃骨头!");
	}
	public void sleep(){
		System.out.println("狗趴着睡觉!");
	}
	public void kanmen(){
		System.out.println("狗会看门");
	}
}
//跳高猫类  子类
class JumpCat extends Cat implements AnimalTrain{
	public JumpCat(){}
	public JumpCat(String name,int age,String color){
		super(name,age,color);
	}
	public void jump(){
		System.out.println("猫会跳高!");
	}
}
//跳高狗类  子类
class JumpDog extends Dog implements AnimalTrain{
	public JumpDog(){}
	public JumpDog(String name,int age,String color){
		super(name,age,color);
	}
	public void jump(){
		System.out.println("狗会跳高!");
	}
}
//测试类
class InterfaceDemo{
	public static void main(String[] args){
		JumpCat jc=new JumpCat("汤姆",3,"灰色");
		System.out.println("姓名:"+jc.getName()+",年龄:"+jc.getAge()+",颜色"+jc.getColor());
		jc.eat();
		jc.sleep();
		jc.jump();
		
		JumpDog dc=new JumpDog("皮卡丘",2,"黄色");
		System.out.println("姓名:"+dc.getName()+",年龄:"+dc.getAge()+",颜色"+dc.getColor());
		dc.eat();
		dc.sleep();
		dc.jump();
	}
}