Java中抽象类和接口定义

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 当多个类中出现相同功能，但是功能主提体不同。 这时可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。
 * 
 * 抽象：看不懂。 
 * 抽象类的特点： 
 * 1.抽象方法一定在抽象类中。 2.抽象方法和抽象类都必须被abstract关键字修饰。
 * 3.抽象类不可以用new创建对象，因为调用抽象方法没意义， 4.抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。
 * 如果子类只覆盖部分抽象方法，那么该子类还是一个抽象类。
 * 
 * 抽象淚和一般類沒有太大的不同。 該如何描述事物，就如何描述失去，只不過，該事物出現了一些看不到的東西。
 * 這些不確定的部分，也是該事物的功能，需要明確出來，但是無法定億主體。 通過抽象方法來表示。
 * 
 * 抽象類比一般類多了個抽象函數。就是在類中可以定義抽象方法， 抽象類不可以實例化。 特殊： 抽象類中可以不定義抽象方法，這樣做僅僅是不讓該類建立對象。
 */

abstract class MyStudent {// 定义一个抽象类
	abstract void study();// 定义抽象方法

	void sleep() {// 定义一个功能
		System.out.println("睡觉");
	}
}

class ChongCiStudent extends MyStudent {// 定义一个类继承抽象类
	void study() {// 覆写抽象类中的方法
		System.out.println("冲刺班学习");// 输出打印内容
	}
}

class BaseStudent extends MyStudent {// 定义一个类继承抽象类
	void study() {// 覆写抽象类中的方法
		System.out.println("基础班学习");// 输出打印内容
	}
}

class AavStudent extends MyStudent {// 定义一个类继承抽象类
	void study() {// 覆写抽象类中的方法
		System.out.println("就业班学习");// 输出打印内容
	}
}

public class AbstractDemo {
	public static void main(String[] args) {
		ChongCiStudent ccs = new ChongCiStudent();// 通过子类new对象，调用覆写的抽象方法
		ccs.study();// 调用覆写的抽象方法
		BaseStudent bs = new BaseStudent();// 通过子类new对象，调用覆写的抽象方法
		bs.study();// 调用覆写的抽象方法
		AavStudent as = new AavStudent();// 通过子类new对象，调用覆写的抽象方法
		as.study();// 调用覆写的抽象方法
	}

}

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 练习：假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
 * 奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。 员工类：name id pay
 * 经理类：继承了员工，并有自己特有的bonus。
 * 员工类：name id pay 
 * 经 理类：继承了员工，并有自己特有的bonus。
 */

abstract class Employee {// 定义一个抽象类员工
	private String name;// 定义姓名属性
	private String id;// 定义工号属性
	private double pay;// 定义工资属性

	Employee(String name, String id, double pay) {// 构造函数，对对象的属性进行描述
		this.name = name;// 调用本类对象姓名属性
		this.id = id;// 调用本类对象工号属性
		this.pay = pay;// 调用本类对象工资属性
	}

	public abstract void work();// 定义一个抽象方法
}

class Manager extends Employee {// 定义经理类继承抽象类员工
	private int bonus;// 定义经理的奖金属性

	Manager(String name, String id, double pay, int bonus) {// 构造函数，对经理的姓名，工号，工资，奖金属性进行描述
		super(name, id, pay);// 调用父类中的姓名，工号，工资属性
		this.bonus = bonus;// 调用本来奖金属性
	}

	public void work() {// 覆写父类中的抽象方法
		System.out.println("工作");// 输出打印子类覆写方法内容
	}
}

public class AbstractDemo1 {
	public static void main(String[] args) {// 主函数，整个函数的切入点
		Manager m = new Manager("张三", "XYZY", 10000.85, 30000);// new子类对象，传入具体的姓名，工号，工资，奖金属性已进行初始化
		m.work();// 调用子类中的方法

	}

}

/**
 * 
 * @author zhaocx1
 *
 */
/*
 * 接口：初期理解 ，可以认为是一个特殊的抽象类。
 * 当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
 * 接口：interface
 * 
 * class用于定义类，interface用于定义接口。
 * 接口定义时，格式特点：
 * 1.接口中常见定义：常量，抽象方法。
 * 2.接口中的成员都有固定修饰符。
 *   常量：public static final 类与类是继承关系，类与接口是实现关系，接口与接口是继承关系。
 *   抽象方法：public abstract
 *记住：接口中的成员都是public   
 *
 *接口是不可以创建对象的 ，因为有抽象方法。
 *需要被子类实现的，子类对接口中的方法都覆盖后，子类才可以实例化。
 *否则子类是一个抽象类。
 *
 *接口可以被类多实现。也是对多继承不支持的转换形式。Java支持多实现。
 */

interface Inter//定义一个接口
{
	public static final int NUM=3;//定义接口中的常量，必须遵循规定格式 public static final
	public abstract void show();//定义接口中的方法，方法是抽象的，格式是 public abstract
}
interface InterA//定义一个接口
{
	public abstract void method();//定义接口中的方法
}
class ItDemo//定义一个类
{
	public void function(){}//定义类中的方法
}

class Test extends ItDemo implements Inter,InterA//类在继承类的同时可以实现多个接口
{
	public void show(){}//覆写接口中的方法
	public void method(){}
}


public class InterfaceDemo {
	public static void main(String[] args)//主函数，整个函数的切入点
	{ 
		Test t=new Test();//对紫劣对象进行实例化
		System.out.println(t.NUM);//调用接口中的成员变量，输出打印内容
		System.out.println(Test.NUM);
		System.out.println(Inter.NUM);
	}
}

/**
 * 
 * @author zhaocx1 练习：一个子类继承一个父类的同时实现一个接口
 */
abstract class BeStudent {//定义一个抽象类
	abstract void study();//定义抽象类中的一个抽象方法

	void sleep() {//定义一般方法
		System.out.println("sleep");//输出打印方法内容
	}
} // 继承是其中的一类，接口是功能的扩展。

interface Smoking {//定义一个接口
	public abstract void smoke();//定义接口中的方法
}

class ZhangSan extends BeStudent implements Smoking {//定义一个子类继承一个抽象类，同时实现一个接口
	void study() {//覆写抽象类中的方法
		System.out.println("xuexijava");//输出打印方法内容
	}

	void sleep() {//覆写抽象类中的方法
		System.out.println("shuijiao");//输出打印方法内容
	}

	public void smoke() {//覆写接口中的抽象方法
		System.out.println("chouyan");//输出打印方法内容
	}
}

public class InterfaceDemo1 {
	public static void main(String[] args) {//主函数，整个函数的切入点

		new ZhangSan().study();//对子类进行实例化，并调用子类中的方法
		new ZhangSan().sleep();
		new ZhangSan().smoke();
	}

}