Java抽象类和接口

1、// 定义抽象类

1.1 定义Pet抽象类（abstract关键字）

public abstract class Pet {

    //创建父类的私有属性
        
	private String name;
	
	private int   age;
	
	private int  health;
	
	private String love;
	
	public Pet(){
	
	//System.out.println("父类无参构造方法");
	
	}
	
	public Pet(String name,int age,int health,String love){
	
		this.name = name;
		
		this.age  =  age;
		
		this.health = health;
		
		this.love  =  love;
		
	//System.out.println("父类有参构造方法")
	
	}
	
	//父类的get方法、set方法
	
	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 int getHealth() {
		return health;
	}	
	public void setHealth(int health) {
		this.health = health;
	}
	public String getLove() {
		return love;
	}
	public void setLove(String love) {
		this.love = love;
	}
	
	
	//定义父类的普通打印方法
	
	public void print(){
		
		System.out .println(name+"\t"+age+"\t"+health+"\t"+love);
		
	}
	
	
	//普通方法
	
	/*public void shout(){
         
        System.out.println("宠物的叫声！");
         
    }*/
    
    //抽象方法：访问修饰符+abstract关键字+返回值+方法名
	
	//抽象方法必须在抽象类中，抽象方法没有方法体（也就是说没有大括号）
	
	public abstract void shout();
		
	
}		

//定义Dog子类extends继承Pet父类

public class Dog extends Pet {

// 子类私有属性
    
	public String strain;
	
//	public Dog() {
//		
//		//System.out.println("子类无参构造方法");
//	}

	public Dog(String name, int age, int health, String love,String strain) {
		
		// Super引用父类属性
		
		super(name, age, health, love);
		
		//System.out.println("子类有参构造方法"); 
		
	}
	
	// 子类get方法
	
//	public String getStrain() {

//		return strain;
//	}

//     子类set方法

//	public void setStrain(String strain) {

//		this.strain = strain;

//	}

	//子类方法重写
	
//	public void print(){		

//       //Super引用父类方法

//		System.out.println(super.getName()+"\t"+super.getAge()+"\t"+super.getHealth()+"\t"+super.getLove()+"\t"+strain);

//	}
	
	public void shout(){
		
		System.out.println("名叫"+this.getName()+"的小狗汪汪的叫！");
		
	}
	
}

//定义PetDemo测试类

public class PetDemo {

	public static void main(String[] args) {
		
//		Dog dog = new Dog("旺财",2,100,"友爱","泰迪");

		//dog.setName("旺财");
		
		//dog.strain="泰迪";
		
		//dog.setAge(2);
		
		//dog.setHealth(100);
		
		//dog.setLove("友爱");
		
//		System.out.println(dog.getName()+"\t"+dog.strain+"\t"+dog.getAge()+"\t"+dog.getHealth()+"\t"+dog.getLove());

//		dog.print();

//		Penguin penguin = new Penguin();

//		Pet pet1 = new Dog();

////		Pet pet2 = new Penguin();

//		pet1.shout();

////		pet2.shout();
//		Petshop petshop = new Petshop();
		
//		Pet pet3 = petshop.BuyPet();
		
//		pet3.shout();
		
//		if(pet3 instanceof Dog){
			
//			Dog dog1 = (Dog)pet3;

//			System.out.println(dog1.getStrain());
			
//		}else{

			
//			Penguin penguin1 = (Penguin)pet3;

//			System.out.println(penguin1.getSex());

//		}
		
		Pet dog = new Dog("旺财",12,100,"友爱","泰迪");
		
		dog.shout();
		
}

结果验证：

名叫旺财的小狗汪汪的叫！

1.2 抽象类

抽象方法（必须在抽象类中）

必须使用abstract关键字

抽象类不能被实例化，它可以具有抽象方法或者普通方法

需求说明

实现某公司各种岗位的员工薪水计算，输出不同岗位各一名员工的工资。要求使用抽象类实现

分析

定义员工抽象类，具有计算薪水的抽象方法

定义子类：经理类、销售人员类、普通员工类，分别继承员工抽象类，重写计算薪水的方法；

定义测试类，包含输出薪水的方法，参数为员工对象；

	// 定义员工Staff抽象类

public abstract class Staff {

	// 定义员工的salary薪水变量（私有属性）
	
	private double salary ;
	
	// 员工类的无参构造方法

	public Staff() {
		
		}
	
	// 员工类的有参构造方法
	
	public Staff(double salary) {
		
		this.salary = salary;
		
	}

	// 薪水的getSalary方法
	
	public double getSalary() {
		return salary;
	}

	// 薪水的setSalary方法
	
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	// 计算薪水的抽象方法
	
	public abstract void calcSalary();
	
}			

	// 销售员工market的类继承Staff员工类

public class market extends Staff {

	// 子类无参构造方法

	public market() {
		
		super();
		
	}

	// 子类的有参构造方法
	
	public market(double salary) {
		
		super(salary);
		
	}

	// 重写父类的抽象方法，calcSalary名称一致
	
	public void calcSalary(){
		
		System.out.println("销售的薪水为："+(this.getSalary()+50000*0.06));
		
	}

}

// 定义销售员工的测试类进行验证

public class marketDemo {

	public static void main(String[] args) {
		
		Staff mar = new market(500);
		
		mar.calcSalary();
		
	}

}

结果验证：

销售的薪水为：3500.0

2、Java接口

示例 // 定义电源插座的接口，具有供电的能力；

package study;

//    定义Socket接口

public interface Socket {

//	定义接口的抽象方法
	
	public  void  getPower();
	
}

//定义类：电视类实现电源插座接口；

package study;

// 定义电视机TV类引用Socket接口

public  class TV implements Socket{

// 重写引用接口的方法 getPower要一致
	
	public void getPower(){
		
		System.out.println("电视机插入电源插座开始播放电视节目。");
		
	}
	
}

//定义测试类，包含电器开始工作的方法，参数为电器对象；

package study;

//   定义测试类

public class SocketDemo {
	
	public static void main(String[] args) {
		
//	创建对象
		
	Socket tv = new TV();
	
	tv.getPower();
	
	}
}

结果验证：

电视机插入电源插座开始播放电视节目。

3、实现多个接口

练习

需求说明

在职研究生既要学习，还要工作，使用实现多个接口的方式定义研究生类；

分析

定义人类作为抽象父类，包含人的基本属性和行为；

定义学习接口，拥有学习能力 ；

定义工作接口，拥有工作能力；

定义研究生类，继承人类，同时实现学习接口和工作接口；

// 定义Person_student抽象类（父类）

public abstract class Person_student {
    
    // name属性
     
	public String name;

	// 构造方法
	
	public Person_student(String name) {
	
		super();
		
		this.name = name;
		
	}

	// get方法
	
	public String getName() {
	
		return name;
		
	}

	// set方法
	
	public void setName(String name) {
	
		this.name = name;
		
	}
	
}

// 定义Work工作接口

public interface Work {

	public void getWork();
	
}

// 定义Study学习接口
public interface Study {

	public void getStudy();
	
}

// 定义Graduate_student研究生类继承Person_student父类，实现Work,Study接口

public  class Graduate_student extends Person_student implements Work,Study {

	// 继承父类属性name
	
	public Graduate_student(String name) {
	
		super(name);
		
	}

	// 实现Work接口，重写Work接口中的getWork方法
	
	public void getWork(){
	
		 System.out.println(this.getName()+"研究生具有工作能力。");
		 
	}
	
	// 实现Study接口，重写Study接口中的getStudy方法
	
	public void getStudy(){
	
		 System.out.println(this.getName()+"研究生具有学习能力。");
		 
	}
}

// 定义测试类

public class GraduateDemo {

	public static void main(String[] args) {
		
	// 新建Graduate_student对象stu
		
	Graduate_student stu = new Graduate_student("张三");
	
	stu.getStudy();
	
	stu.getWork();
	
    }
}

结果验证：

张三研究生具有学习能力。

张三研究生具有工作能力。

转载于:https://blog.51cto.com/vipnoon/1795087