java笔记-面向对象-继承、抽象类、模版设计模式

面向对象：继承

/*
** 继承：
** 将对象与对象的共性描述抽取出来，单独进行描述,在子类中使用extends关键字；
** 优点：提高了代码的复用性；
** 让类与类之间产生了关系，有了这个关系，才有了多态的特性。
** 必须是类与类之间有所属关系才可以继承。
** java只支持单继承，不支持多继承（多继承容易带来安全隐患，多个父类中继承相同功** 能时，子类对象不知道要运行哪一个）；java保留多继承机制，用另外一种形式（多实现）；
** 如何使用继承体系中的功能？
** 先查阅父类，父类定义了体系的共性内容。
** 在使用时，要创建最子类的对象。1.父类可能不能创建对象；2.子类对象可以使用更多功** 能。
*/
class Person{
	private int age;
	private String name;
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age=age;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
}
class Student extends Person{
	public void study(){
		System.out.println("Student Sdudy!");
	}
}
class Worker extends Person{
	public void work(){
		System.out.println("worker work!");
	}
}
class jicheng{
	public static void main(String[] args){
		Student stu=new Student();
		Worker wor=new Worker();
		stu.setName("sike");
		wor.setName("work");
		System.out.println("Student:"+stu.getName()+";\tWorker:"+wor.getName()+".");
		stu.study();
		wor.work();
	}
}

继承：子类和父类变量的特点

/*
** 如果子类中出现父类中非私有的同名成员变量；
** 子类访问本类中的变量用this;
** 子类访问父类中的变量用super；
** super的使用和this几乎一致；
*/
class Parents{
	int num=4;		//该类有子类，num在哪里？参看一
}
class children extends Parents{
	int num=5;
	public void show(){
		System.out.println(super.num);		//super：使用父类num
	}
}
class ExtendsDemo{
	public static void main(String[] args){
		children child=new children();		//参看一：对象创建时：分别开辟子类和父类的空间，各自num存在各自类的空间。
		child.show();
	}
}

final关键字

/*
** final:最终，作为一个修饰符；
** 修饰类，函数，变量；
** 被final修饰的类不能被继承（继承打破封装性）；
** 为了避免继承，被子类复写；
** 被final修饰的方法不能复写；
** 被final修饰的变量为常量，只能赋值一次，成员变量和局部变量都可以修饰；
** 常量的书写规范：所有字母大写，若由多个单词组成，单词间用"_";
** 内部类定义在类中的局部位置时，该类只能访问该局部被final修饰的局部变量；
*/
class Demo{
	final int x=3;
	public static final double PI=3.14;	//固定值,共享，全局常量；
	public final void show1(){};	//不能复写;
	public void show2(){
		//x=5; //执行该语句提示“不能为最终变量x分配值”
	};
}
class SubDemo extends Demo{
	//void show1(); 	//该语句不能执行,提示“无法覆盖Demo中的show1()”；
}
class FinalDemo{
	public static void main(String[] args){
		System.out.println("world!");
	}
}

抽象类：

/*
** 多个类中含有相同功能，但该功能主体不同；
** 此时可以进行向父类抽取，只抽取功能定义，而不抽取主体；
** 含有抽象方法的类也有抽象类，必须用abstract修饰，抽象类不能构建对象；
** 子类如果使用父类抽象方法必须重写，倘若不能重写所有父类抽象方法，
** 由于子类继承父类，则子类中含有未重写的抽象方法，子类也必须为抽象类，
** 需用abstract修饰。
** 抽象类比一般类多了抽象方法；不能实例化。
** 抽象类可以不定义抽象方法，这样做可以禁止对该类创建对象；
*/
abstract class Student{		//类中含有抽象方法，该类为抽象类；
	abstract void Study();	//抽象方法，无实体内容，无实体（强迫复写）；
}
class BaseStudent extends Student{	//继承抽象类；
	public void Study(){			//重写抽象访法；
		System.out.println("BaseStudent!");
	}
}
class AdvanceStudent extends Student{
	public void Study(){			//重写抽象方法；
		System.out.println("Advance Student!");
	}
}
class AbstractDemo{
	public static void main(String[] args){
		new BaseStudent().Study();		//使用继承后的抽象方法；
		new AdvanceStudent().Study();	//使用继承后的抽象方法；
	}
}

抽象类应用实例：

/*
** 设计员工类和经理类
** 员工有三个属性(姓名，工号，工资)和一个方法；
** 经理除了员工的特性外还有奖金；
*/
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 String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public String getId(){
		return id;
	}
	public void setId(String id){
		this.id=id;
	}
	public double getPay(){
		return pay;
	}
	public void setPay(double pay){
		this.pay=pay;
	}
	
	//每个员工都有工作的能力，但具体工作内容不一样；
	public abstract void work();	//无主体的抽象方法,在子类中需重写；
	public abstract void speak();	//让每个员工说出自己的姓名，工号，工资等内容；
	}
class Pro extends Employee{
	Pro(String name,String id,double pay){
		super(name,id,pay);			//继承自父类，使用父类构造函数方法；
	}
	//重新定义抽象方法；
	public void work(){
		System.out.println("Pro work!");
	}
	//重新定义抽象方法；
	public void speak(){
		System.out.println("Name is "+super.getName()+",Id is "+super.getId()+",Pay is "+super.getPay()+".");
	}
}
class Manager extends Employee{
	
	private double bonus;
	//为私有变量提供公共访问方法;
	public double getBonus(){
		return bonus;
	}
	public void setBonus(double bonus){
		this.bonus=bonus;
	}
	//构造函数初始化；
	Manager(String name,String id,double pay,double bonus){
		super(name,id,pay);
		this.bonus=bonus;
	}
	//重新定义抽象方法；
	public void work(){
		System.out.println("Manager work!");
	}
	//重新定义抽象方法；
	public void speak(){
		//父类中私有属性通过公共方法访问；
		System.out.println("Name is "+super.getName()+",Id is "+super.getId()+",Pay is "+super.getPay()+",Bonus is "+this.bonus+".");
	}
}
class Demo{
	public static void main(String[] args){
		//打印普通员工信息；
		Pro p=new Pro("mike","开发001",9999.01);
		p.speak();
		p.work();
		//打印管理人员信息；
		Manager m=new Manager("lucy","Leader001",19999.02,10000.0);
		m.speak();
		m.work();
	}
}

模版设计方法模式：

/*
** 模版方法设计模式
** 在定义功能时，功能的一部分是确定的，另外一部分是不确定的，
** 而确定的部分在使用不确定的部分，此时可将不确定的部分暴漏出去，由子类来完成；
*/

/*
** 函数功能：
** 获取一段程序的执行时间。
*/
abstract class GetTime{		//该类中有一部分功能不确定；使用该类为抽象类；
	//该方法为确定部分，犹如模版，而runCode()部分为不确定的，犹如放在模版中的内容。
	public final void getTime(){
		long start=System.currentTimeMillis();	//使用currentTimeMills()函数获得系统当前运行时间；
		//该部分为不确定部分，定义为抽象方法，交给子类重写；
		runCode();						//程序运行代码；
		
		long end=System.currentTimeMillis();	//程序运行结束，获得程序运行结束时间；
		System.out.println("run code time is "+(end-start)+".");
	}
	public abstract void runCode();		//该功能不确定，使用抽象方法，可在子类中重写；
}
class SubTime extends GetTime{
	//重写的抽象类中的方法；
	public void runCode(){
		for(int x=0;x<3000;x++){
			//程序运行较快，运行该代码可延缓时间；
			System.out.print(x+" ");
		}
	}
}
class TemplateDemo{
	public static void main(String[] args){
		SubTime st=new SubTime();
		st.getTime();
	}
}

接口：

/*
** 接口:
** 刚开始理解时，可将接口看作是一个特殊的抽象类，
** 该类中的所有方法都是抽象的，反过来，若抽象类中的所有方法
** 都是抽象的，则该类可通过接口的形式实现；
** 特点：常见定义：常量，抽象方法；
** 接口中的成员都有固定的修饰符；
** 常量: public static final
** 方法：public abstract
** 对于接口，上述修饰符可不用，系统会自动补上，但为了可读性
** 建议写上。
** 无多继承，接口与接口间存在多继承，除此之外没有。
*/
interface Inter{
	public static final int num=3;		//公有静态常量；
	public abstract void show();		//抽象方法，在子类中重写；
}
interface InterA{
	public abstract void method();
}
class Test implements Inter,InterA{		//多实现；
	public void show(){		//重写show方法；
		System.out.println("Test Interface.");
	}
	public void method(){}	//重写method方法；
}
interface InterC extends Inter,InterA{	//接口与接口间的多继承，

}
class InterD implements InterC{
	//类继承自接口，需要重写接口中的抽象方法；
	public void show(){}		//重写接口中的抽象方法；
	public void method(){}		//重写接口中的抽象方法；
}
class InterfaceDemo{
	public static void main(String[] args){
		Test t=new Test();
		t.show();
		//Inter.show();		//该语句不能执行；show()非静态。
		System.out.println(t.num);
		System.out.println(Inter.num);
	}
}

接口的具体实现：

/*
** 继承：所属于；
** 接口：功能扩展；具体实现由子类实现；
*/
abstract class Student{		//类中含有抽象方法；
	public abstract void study();	//具体学习内容不祥；
	public void sleep(){
		System.out.println("Students sleep!");
	}
}
class PriStudent extends Student{
	public void study(){	//重写抽象类中的方法；
		System.out.println("Study java!");
	}
}
interface Smoke{			//给部分抽烟的学生提供吸烟接口
	public abstract void smoking();	//接口中的所有方法均为抽象方法；
}
//新类，继承父类，实现接口；
class SmokeStudent extends PriStudent implements Smoke{
	//重写接口方法；
	public void smoking(){
		System.out.println("帝豪!");
	}
}
class InterDemo{
	public static void main(String[] args){
		SmokeStudent ss=new SmokeStudent();
		ss.smoking();
		ss.study();
	}
}