java day7 final 抽象类 接口等 2019.7.15

• 子父类中构造函数的特点
• final修饰符
• 抽象类
• 抽象类实战
• 模板方法模式
• 接口
• 接口的混合继承
• 接口具体举例

子父类中构造函数的特点

/**
父类中的构造函数也被调用的原因：
每一个子类中构造函数前会默认有一条super();
但是当父类中没有无参的构造函数，就必须手动的调用父类的构造函数（必须写，不然会调用隐式的super（）造成错误）
比如父类中fu(int x),子类第一行必须先super(3);
*/

class fu
{
	fu()
	{
		System.out.println("fu");
	}
}


class zi extends fu
{
	zi()
	{
		//super();
		System.out.println("zi");
	}
	zi(int x)
	{
		//this();如果写了这句，则也不会有super（）;只会有一个构造语句执行
		//super();//依旧是super而不是super（4）
		System.out.println("zi.....x");
	}
}

class Demo3 
{
	public static void main(String[] args) 
	{
		zi z=new zi();
		zi z1=new zi(4);
		//System.out.println("  "+z.num);
	}
}

final修饰符

/*
final：最终，最为一个修饰符
1.可以修饰类，函数，变量
2.被final修饰的类不可以被继承，为了避免被继承，被子类复写功能
3.被final修饰的方法不会被复写 
4.被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以写诗局部变量
  即使是赋相同的值也叫赋值
  如果变量被final修饰，变量必须全部大写。
*/

抽象类

/*
当多个类中出现相同功能，但是功能主体不同，
这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主题。

抽象：即看不懂

抽象类的特点：
1.抽象方法一定定义在抽象类中
2.抽象方法和抽象类必须都被abstract修饰
3.抽象方法不可以用new创建对象。因为调用抽象方法没有意义
4.抽象类中的方法要被使用，必须由子类复写其所以的抽象方法后，建立子类对象使用
  如果不复写所有的抽象方法，那么该子类还是一个抽象类

抽象类和一般类没有太大的不同
该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西
这些不确定的部分，也是事物的功能，需要明确出现，但是无法定义主体
通过抽象方法来表示

抽象类比一般类多了个抽象函数，就是可以在类中定义抽象方法（也不可没有抽象方法）
抽象类不可以实例化

特殊：抽象类中可以不定义抽象方法，这样仅仅是不让该类建立对象

*/


abstract class Stu
{
	abstract void study();
}

class BaseStu extends Stu
{
	void study()
	{
		System.out.println("base learn");
	}
}

class AdvStu extends Stu
{
	void study()
	{
		System.out.println("Adv learn");
	}
}

class StuDemo 
{
	public static void main(String[] args) 
	{
		new AdvStu().study();
	}
}

抽象类实战

/*抽象类实战

发现父类的私有变量可以继承，但是不能使用。。。。。。
*/


abstract class Employee
{
	private String name;
	private int age;
	private int pay;
	Employee(String name,int age,int pay)
	{
		this.name=name;
		this.age=age;
		this.pay=pay;
	}

	public abstract void work(); 
}

class ProWork extends Employee
{
	ProWork(String name,int age,int pay)
	{
		super(name,age,pay);
	}

	public void work()
	{
		//System.out.println(super.name+"  "+super.age+"  "+super.pay);
		System.out.println("Pro work");
	}
}

class Manager extends Employee
{
	private int bonus;
	Manager(String name,int age,int pay,int bonus)
	{
		super(name,age,pay);
		this.bonus=bonus;
	}
	
	public void work()
	{
		//System.out.println(name+"  "+age+"  "+pay+"  "+bonus);
		System.out.println("man work");
	}
}
class ShiZhan
{
	public static void main(String[] args) 
	{
		new Manager("zhangsan",40,8000,2000).work();
		new ProWork("lisi",40,5000).work();
	}
}

模板方法模式

abstract class GetTime//zhege
{
	public final void aha()//此部分不允许被修改，加上final修饰符
	{
		long start=System.currentTimeMillis();

		run();//如此之作只需要这一部分代码即可；

		long end=System.currentTimeMillis();

		System.out.println("运行毫秒："+(end-start));

	}

	public abstract void run();//用public把允许修改的部分暴露出去
}

class Get extends GetTime
{
	public void run()
	{
		for(int x=1;x<=1000;x++)
		{
			System.out.print(x+" ");
		}
	}
}

class TimeDemo 
{
	public static void main(String[] args) 
	{
		new Get().aha();
	}
}

接口

/*
接口：初期理解，可以认为是一个特殊的抽象类
   当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示

class用于定义类
interface用于定义接口

接口定义时，格式特点：
1.接口中常见定义：常量。抽象方法。
2.接口中的成员都有固定修饰符
   常量：public static final
   方法：public abstract

 结论：接口中的成员都是public的


接口：时不可以创建对象的，因为有抽象方法
需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化
否则子类是一个抽象类

*/

interface Inter
{
	public static final int NUM=3;
	public abstract void show();
}

class Test implements Inter
{
	public void show(){}
}

class  Demo4
{
	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);
	}
}

接口的混合继承

/*
接口可以被类多实现，也是多不支持继承得转换形式。Java支持多实现

而且，接口之间也可以继承，还可以多继承

*/

interface Inter
{
	public static final int NUM=3;
	public abstract void show();
}

interface InterA
{
	public abstract void method();
}

class function
{
	public void speak(){}
}

class Test extends function implements Inter,InterA
{
	public void show(){}
	public void method(){}
}


class  Demo5
{
	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);
	}
}

接口的具体举例

abstract class Stu
{
	public abstract void study();//每个人都会学习，但学习的内容不同，所以是抽象的
}



interface Smoking//可以把接口理解为一个对象的拓展功能，并不是每个人都会抽烟，像插件一样
{
	public abstract void smoke();
}

class lise extends Stu implements Smoking
{
	public void study()
	{
		System.out.println("study java ");
	}

	public void smoke()
	{
		System.out.println("i like somke");
	}
}

class Demo6 
{
	public static void main(String[] args) 
	{
		new lise().study();
	}
}