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();
}
}结果验证：
张三研究生具有学习能力。
张三研究生具有工作能力。