Day07 面向对象

Day07 面向对象

——继承、聚集、子父类中变量、final、抽象类、接口

4 继承

4.1 继承的概述
4.2 继承的特点
继承：1.提高了代码的复用性。2.让类与类之间产生了关系。有了这个关系，才有了多态的特性。

/*
将学生和工人的共性描述提取出来，单独进行描述。
只要让学生和工人与单独描述的这个类有关系就可以了。
*/
class Person
{
	String name;
	int age;
}
class Student extends Person
//Student继承了Person，Stedent是Person的子类，Person是Student的父类（基类、超类），子类继承父类
{
	void study()
	{
		System.out.println("good study");
	}

}
class Worker extends Person
{
	void work()
	{
		System.out.println("good work");
	}
//在这些类中有一些共性的数据和描述
}
class  ExtendsDemo
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.name = "zhangsan";
	}
}

注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系 is a。父类中的功能是不是子类中应该具备的，如果父类中有的功能不是子类应该具备的，那么他们之间就不应该有继承。
class C
{
void demo1(){}
}
class A extends C
{
//void demo1(){}
void demo2(){}
}
class B extends C
//A不能继承B
{
//void demo1(){}
void demo3(){}
}
Java语言中，只支持单继承，不支持多继承。（单继承：一个孩子只有一个父亲）
因为多继承容易带来安全隐患:当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是java保留了这种机制，并用另一种体现形式来完成表示，多实现。
class A
{
void show()
{
System.out.println(“a”);
}
}
class B
{
void show()
{
System.out.println(“b”);
}
}
class C extends A,B
{}

C c = new c();
c.show();
Java支持多层继承。也就是一个继承体系。如何使用一个继承体系中的功能呢？
要想使用体系，先查阅体系父类的描述，因为父类中定义的是该类体系中共性功能。通过了解共性功能，就可以了解该体系的基本功能。那么这个体系已经可以基本使用。
那么在具体调用时，要创建最子类的对象，为什么呢？
1.因为有可能父类不能创建对象。2.创建子类对象可以使用更多的功能，包括基本的也包括特有的。
简单一句话：查阅父类功能，创建子类对象使用功能。

聚集：has a
聚合：班级由一帮人组成，人就是班级中的一员。一个球队，由很多队员组成，队员是球队中的一员。队员和球队的关系是聚合关系。
组合：事物的联系程度更紧密。手和心脏是人身体的一部分。（球队中少了一个队员没事，人身体不能少哪一部分）

子父类中变量的特点
类中成员：
1.变量
2.函数
3.构造函数
4.3 super关键字
1.变量。如果子类中出现非私有的同源成员变量时，子类要访问类中的变量，用this。子类要访问父类中的同名变量，用super。super的使用和this的使用几乎一致。this带边的是本类对象的使用。super代表的是父类对象的使用。

class Fu
{
	int num1 = 4;
}
class Zi extends Fu
{
	int num2 = 5;
}
class  ExtendsDemo2
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		System.out.println(z.num1 + "..." + z.num2);//-->4...5
	}
}

class Fu
{
	int num = 4;
}
class Zi extends Fu
{
	//int num = 5;
	void show()
	{
		System.out.println(num);//this.num本类对象引用
		System.out.println(super.num);//对父类对象的引用
		System.out.println(num);//-->4 super.num
		System.out.println(this.num);//-->4
	}
}
class  ExtendsDemo2
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();//->5
		//System.out.println(z.num + "..." + z.num);//-->5...5父类和子类有相同变量，打印子类的
	}
}

4.4 函数覆盖
2.子父类中的函数
当子类出现和父类一模一样的函数时：当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。这种情况是哈书的另一种特性：重写（覆盖）。
覆盖还可以用于扩展:当子类继承了父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致。这时，没必要定义新功能，而是使用覆盖特性，保留父类的功能定义并重写功能内容。
覆盖：
1.子类覆覆盖父类，必须保证子类权限大于父类权限，才可以覆盖，否则编译失败。
2.静态只能覆盖静态。
已学权限：private public 默认权限（什么也不写，介于共有和私有之间）
注：重载：只看同名函数的参数列表。
重写：子父类方法要一模一样（包括返回值类型）。

class Fu
{
	void show1()
	{
		System.out.println("fu show");
	}
}
class Zi extends Fu
{
	void show2()
	{
		System.out.println("zi show");
	}
}
class  ExtendsDemo2
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show1();
		z.show2();
	}
}

–>fu show
zi show

class Fu
{
	void show()
	{
		System.out.println("fu show");
	}
	void speak()
	{
		System.out.println("vb");
	}
}
class Zi extends Fu
{
	void show()
	{
		System.out.println("zi show");
	}
	void speak()
	{
	System.out.println("java");
	}
}
class  ExtendsDemo2
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();
	}
}

–>zi show
覆盖还可以用于扩展

class Tel
{
	void show()
	{
		System.out.println("number");
	}
}

class NewTel extends Tel
{
	void show()
	{
		//System.out.println("number");
		super.show();
		System.out.println("name");
		System.out.println("pic");
	}
}

覆盖：子类沿袭父类功能，private子类不知道父类有的功能，所以不是覆盖，但是可以编译通过。子类知道才有覆盖的可能。

不是覆盖：父类权限大于子类权限。

可以覆盖。


4.5 子类的实例化过程
3.子父类中的构造函数
在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数默认的第一行有一句隐式的语句super()
super()：会访问父类中空参数的构造函数，而且子类中所有的构造函数默认的第一行都是super()
为什么子类一定要访问父类中的构造函数？
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要查看父类是如何对这些数据进行初始化的，所以子类在对象进行初始化是要先访问下父类的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。
注意：super语句一定是在子类构造函数的第一行
子类的示例化过程
结论：
子类的所有的构造函数，默认都会访问父类中空参数的构造函数

因为子类每一个构造函函数内的第一行都有一句隐式的super
当父类中没有空参数的构造函数时候，子类必须手动通过super语句形式来访问父类中指定的构造函数
当然：子类中的构造函数第一行也可以手动的指定this语句来访问本类中的构造函数
子类中至少也会有一个构造函数会访问父类中的构造函数

class father //extends object //这个是所有类的父类 
{
	private String word;
	father()
	{
		System.out.println("Father 1");
	}
 
	father(String word)
	{
		this.word = word;
		System.out.println("Father 2 " + word);
	}
 
}
 
class sun  extends father
{
	sun()
	{
		super();//不写也会被隐式调用
		System.out.println("Sun 1");
	}
 
	sun(String word)
	{
		super(word);
		System.out.println("Sun 2 " + word);
	}
 
}
 
class  ExtendDemo
{
	public static void main(String []args)
	{
		String w = "run...";
		sun s = new sun();
		System.out.println("---------------");
		sun ss = new sun(w);	
	}
} 

4.6 final关键字
1.final修饰符。可以修饰类，方法（函数），变量。
2.final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3.final修饰的方法不可以被覆盖。
4.final修饰的变量是一个常量。只能被赋值一次。既可以修饰成员变量，又可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，为了方便于阅读。而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范都大写，如果由多个单词组成，单词间通过_连接。
final double MY_PI = 3.14;
public static final double MY_PI = 3.14;–>全局常量：权限够大，类名调用，值不会变
5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
修饰类：public/final/什么也不写 class
修饰成员：public/final/private/什么也不写

x,y的值已经定了，无法再被赋值为其他值。

4.7 抽象类
当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。只抽取功能定义而不抽取功能主体。
抽象：看不懂。
抽象类的特点：1.抽象方法一定在抽象类中。2.抽象方法和抽象类都必须被abstract关键字修饰。3.抽象类不可以用new创建对象么因为调用抽象方法没意义。4.抽象类中的抽象方法要被使用，必须由子类复写其所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

如果真的实例化成功的话，调用study方法没有意义，没有执行体

这样可以，因为有方法体，只不过方法体内没有写内容。

抽象类的细节：
1：抽象类中是否有构造函数？有，用于给子类对象进行初始化。
2：抽象类中是否可以定义非抽象方法？
可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。
3：抽象关键字abstract和哪些不可以共存？final , private , static
4：抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。
抽象类练习
假如我们在开发一个系统时需要对员工进行建模，员工包含3个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另外还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必须要的犯法进行属性访问。
员工类：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;
		ehis.pay = pay;
	}
	public abstract void work();//员工工作描述不具体-->抽象
}

class Manger extends Employee
{
	private int bonus;
	Manger(String name,String id,double pay,int pay)
	{
		super(name,id,pay);
		this.bonus -= bonus;
	}
	public void work()
	{
		System.out.println("manger work");
	}

}
class Pro extends Employee
{
	Pro(String name,String id,double pay)
	{
		super(name,id,name);

	}
	public void work()
	{
		System.out.println("Pro work");
	}

}
class  AbstractText
{
	public static void main(String[] args) 
	{
		
	}
}

模板方法模式

什么是模板方法呢？在定义功能时，功能的一部分是确定的。但是有一部分是不确定的。而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴露出去，由该类的子类去完成。

//获取时间类
abstract class GetTime 
{
    //获取runCode函数的运行时间方法
    public final void getTime()
     {
     	long start = System.currentTimeMillis();
       //不确定的功能代码
       runCode();   
       long end = System.currentTimeMillis();
       System.out.println("毫秒数：" + (end - start));
    }
    //不确定的方法runCode，需要由子类去实现
    public abstract void runCode();
}
//GetTime类的子类，该类需要实现runCode方法
class SubTime extends GetTime {
    //实现runCode方法的具体细节
    public void runCode() {
       for (int x = 0; x < 100000; x++) {
           System.out.println(x);
       }
    }
}
//模板测试类
public class TemplateDemo {
    public static void main(String[] args) {
       //创建子类的实例对象
       SubTime time = new SubTime();
       //调用getTime方法，打印结果
       time.getTime();
    }
}

4.8 接口
接口：初期理解，可以理解为特殊的抽象类。当抽象类中的方法都是抽象的，那么该类及恶意通过接口的形式来表示。
class用于定义类。interface用于定于接口。
接口定义时，格式特点：
1.接口中常见定义：常量，抽象方法
2.接口中的成员都有固定修饰符。接口中的成员都是public
成员常量：public static final
成员函数：public abstract

interface Inter
{
	public static final int NUM = 3;
	public abstract void show();
}
class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

–>abstract class Demo
{
void show(){}
}
或
class Demo
{
abstract void show(){}
}
类与类之间是继承关系extends，类与接口之间是实现 implements，接口与接口之间是继承关系。（写内容叫实现，不写内容叫继承）
接口是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全部都覆盖后，子类还可以实例化，否则子类是一个抽象类。
接口的出项将“多继承”通过另一种形式体现出来，即“多实现”。
不支持多继承的原因：父类中的方法有重复，在子类调用时会产生问题，多继承的方法里有方法体。多实现的方法里没有方法体，可以由子类任意定义。

interface Inter
{
	public static final int NUM = 3;
	public abstract void show();
}
interface InterA
{
	public abstract void show();
}
class Demo
{
	public void function(){}
}
class Test extends Demo implements Inter,InterA
//类先继承再实现可以扩展类的功能
{
	public void show(){}	
}

//继承extends 实现implements interface定义接口
//类与类之间是继承关系extends，类与接口之间是实现 implements，接口与接口之间是继承关系。
//（写内容叫实现，不写内容叫继承）
interface A
{
	void methodA();
	//int show();
}
interface B //extends A
{
	void methodB();
	//boolean show();
}
interface C extends B,A//接口之间存在多继承
{
	void methodC();
} 
class D implements C
{
	public void methodA(){}
	public void methodB(){}
	public void methodC(){}
	//public int show(){}
	//public boolean show(){}-->这种情况不允许出现，两种返回值类型不一致
}


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);
		//编译完后又3个：Inter.class InterfaceDemo.class Test.class
		//上面三者任意一个都不能对Num进行赋值，是常量
	}
}

接口的特点
接口是对外暴露的规则。
接口是程序的功能扩展。
接口可以用来多实现。
类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系。
接口举例体现

/*
abstract class Student
{
	abstracrt void study();
	void sleep()
	{
		System.out.println("sleep");
	}
	
}
interface Smoking
{
	void smoke();
}
class Zhangsan extends Student implements Smoking
//体系以外的功能的扩展，用于扩展其他类中的内容
//继承：is a 所属，你是我其中的一种，张三是学院中的一种，烟民是人的扩展功能
//接口：like a 你像我中的一个，体系外功能由后期子类实现
//基本功能定义在类中，扩展功能定义在接口中
{
	void study(){}
	public void smoke(){}
}
class LIsi extends Student 
{
	void study(){}
	
}

*/

abstract class Sporter
{
	abstract void play();//不确定，抽象
}
interface study
{

}
class wangwu extends Sports implements Study
{
}

class 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}