07day
1.继承
继承：提高了代码的复用性，让类与类之间产生了关系，有了这个关系，才有了多态的特性。
Java语言中，Java只支持单继承，不支持多继承。
因为多继承容易带来安全隐患。当多个类中定义了相同的功能，当功能内容不同时，子类对象不确定要运行哪一个父类的功能。
但Java保留了这种机制 ，并且用一种体现形式来完成表示，多实现。
/*
class A
{
void show();
}
class B
{
void show();
}
class C extends A,B
{
}
C c = new C();
c.show(); //如果上面继承关系成立，这是c.show()不知道运行哪个父类的show()方法。
*/
Java支持多层继承。
/*
class A
{
void show();
}
class B extends A
{
void show();
}
clsss C extends B
{
}
B b = new B();
b.show();
C c = new C();
c.show();
*/
2.子父类出现后，类成员的特点。
2.1 变量
如果子类中出现非私有的同名变量时，子类访问本类中的变量用this。子类要访问父类中的同名变量,用super。
class Fu
{
int num = 6;
}
class Zi extends Fu
{
int num = 42;
void show()
{
System.out.println(super.num);
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
System.out.println("z.num");
z.show();
}
}
2.2 子父类中的函数
当子类出现和父类一模一样的函数时，子类对象调用该函数，会调用子类函数的内容。这就是函数的另一个特性,重写(覆盖)。
当子类继承父类，就沿袭了父类的功能。当子类功能内容和父类功能不一致时，子类不必定义新功能，使用覆盖特性，保留父类的功能定义，并重写功能。
继承时的覆盖：
1.子类覆盖父类，必须保证子类的权限大于等于父类权限，才可以覆盖，否则编译失败。
2.静态只能覆盖静态
class Fu
{
void show()
{
System.out.println("fu show");
}
}
class Zi extends Fu
{
void show()
{
System.out.println("zi show");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Zi z = new Zi();
z.show();
}
}
2.3 子父类中的构造函数
在子类对象进行初始化时，子类的构造函数默认第一行有一条隐式语句super(); 所以父类的空参数构造函数也会运行。并且子类所有的构造函数第一行默认都是super();
super():会访问父类中的空参数构造函数。
为什么子类一定要访问父类中的构造函数
因为父类中的数据子类可以直接获取，子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。
如果需要访问父类中指定的构造函数，可以通过手动定义super()语句的方式来指定。
当父类中没有空参数的构造函数时，子类必须通过手动super()语句来指定访问父类中的构造函数。
当然，子类的构造函数也可以通过手动指定 this(); 语句访问本类构造函数
class Fu
{
Fu()
{
System.out.println("fu run");
}
}
class Zi extends Fu()
{
Zi()
{
//super();
System.out.println("zi run");
}
Zi(String s)
{
//super();
System.out.println("zi run ："+s);
}
class ExtendsDemo
{
public static void main(String args)
{
Zi z = new Zi();
Zi z1 = new Zi();
}
}
3.final 关键字
3.1 final 可以修饰类、函数、变量。
3.2 final修饰的类不可以被继承。
/*
final class A
{
void show();
}
class B extends A //编译错误，不可继承
{
}
*/
3.3 final修饰的函数不可以被覆盖。
/*
class A
{
final void show();
}
class B extends A
{
void show();//编译错误，不可覆盖
}
*/
3.4 final修饰的变量是一个常量，只能被赋值一次。
/*
class A
{
final double PI = 3.1415926；
void show()
{
PI = 3.14; //编译错误，只能被赋值一次。
}
}
*/
3.5 内部类只能访问被final修饰的局部变量。
4.抽象类 abstract
1.含有抽象方法的类都是抽象类
2.抽象类不能用new创建对象，因为调用抽象方法没意义。
3.抽象类中的方法被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。
抽象类和一般类的区别
抽象类练习
假如我们在开发一个系统时需要对员工进行建模，员工包含3个属性(姓名、工号、工资)。
经理也是员工，除了含有员工的属性外，另外还有一个奖金属性。请使用继承的思想设计
出员工类和经理类。要求类中提供必要的方法进行属性访问。
class Employee
{
private String name = "";
private String employeeId = "";
private double pay = -1;
Employee(String name, String employeeId,double pay)
{
this.name = name;
this.employeeId = emoloyeeId;
this.pay = pay;
}
public abstract void work();
}
class ManagerEmployee extends Employee
{
private double bonus = -1;
ManagerEmployee(String name, String employeeId,double pay,double bonus)
{
super(name,emoloyeeId,pay);
this.bonus = bonus;
}
public void work()
{
System.out.printle("Do Manager Work");
}
}
class ProfessionalEmployee extends Employee
{
ProfessionalEmployee(String name, String employeeId,double pay)
{
super(name,emoloyeeId,pay);
}
public void work()
{
System.out.printle("Do Professional Work");
}
}
/**
模板方法设计模式
在定义功能室，功能的一部分是确定的，但是有一部分是不确定的。
而确定的部分在使用不确定的部分。解决这个问题可以使用模块方法
设计模式
将不确定的部分暴露出去，由该类的子类去完成
*/
abstract class GetTime
{
public final void getTime()
{
long statTiem = System.currentTimeMillis();
runcode();
long endTiem = System.currentTimeMillis();
System.out.println("该程序使用了"+(endTiem-statTiem)+"毫秒");
}
public abstract void runcode();
}
class SubTiem extends GetTime
{
public vodi runcode()
{
for (int x=0;x<10000 ;x++ )
{
System.out.print(X);
}
}
}
5.接口
接口：可以认为接口是特殊的抽象类。当抽象类中方法都是抽象的，那个可以通过接口的形式来完成。
接口的出现将"多继承"通过另外一种新式体现出来。
class 用于定义类
interface 用于定义接口
implements 用于引用接口
extends 用于继承父类
接口的定义是，格式特点
1.接口中常见定义：常量，抽象方法。
2.接口中的成员都有固定修饰符
常量：public static final
方法: public abstract
接口中的成员都是public的，因为接口就是对外暴露原则的。
接口不可被创建对象，因为有抽象方法。
需要被子类实现后才可以实例化。
接口可以被多个实现
class A extends B implements InterA,InterB
{
}
接口可以被接口继承
interface InterA
{
void methodA();
}
interface InterB extends InterB
{
void methodA();
}
abstract class Student
{
abstract void study();
void sleep()
{
System.out.println("sleep");
}
}
interface Smoking
{
void smoke();
}
class ZhangSan extends Student implements Smoking
{
void study(){}
public void smoke(){}
}
class Lisi extends Student
{
void study(){}
}
//张三抽烟,李四不抽烟，他们都是学生
6.多态：可以理解为事物存在的多种形态
6.1多态的体现:
父类的引用指向了自己的子类对象
父类的引用也可以接收自己的子类对象
6.2多态的前提:
类于类之间有关系，要么继承，要么实现
还有一个前提：存在覆盖关系
6.3多态的好处:
提高程序扩展性
6.4多态的弊端:
只能使用父类的引用访问父类的成员
6.5多态的转型
Animal a = new Animal();
Cat c = (Cat)a; //错误
Animal a1 = new Cat(); //这是向上转型
Cat a2 = (Cat)a1; //可行 ， 这是向下转型
6.6多态中成员函数的特点:
在编译时期：参阅引用类型变量所属的类是否含有调用的方法,如果有，编译通过，如果没有就编译失败
在运行时期：参阅对象所属的类中是否有调用的方法
总的来说：就是成员函数在多态调用时，编译看左边，运行看右边。
6.7多态中成员变量的特点
无论编译和运行，都参考左边
6.8在多态中，静态成员函数的特点：
无论编译和运行，都参考左边
7.内部类
class Inner
{
}
内部类的访问规则：
1、内部类可以直接访问外部类中的成员，包括私有.
原因是内部类中持有外部类的引用： 外部类名.this
2、外部类要访问内部类，必须建立对象
访问格式：
1.当内部类定义在外部类的成员位置上，而且非私有化时
可以再外部其他类中直接建立内部类对象
格式如下：
外部类名.内部类名 变量名 = 外部类对象.内部类对象
Outer.Inner in = new Outer().new Inner();
2.当内部类在成员位置上，就可以被成员修饰符所修饰。
比如：private，将内部类在外部类中进行封装
static ，内部类具备静态属性，只能直接访问外部类中的静态成员。出现了访问局限
在外部其他类中，直接访问static内部类的非静态成员格式如下
new Outer.Inner().function();
在外部其他类中，直接访问static内部类的静态成员格式如下
Outer.Inner().function();
注意：当内部类中定义了静态成员，该内部类必须是static的
当外部类中的静态方法访问内部类时，内部类也必须是static的
当描述事物时，事物的内部还有事物，该事物用内部类来描述，
因为内部事务在使用外部事物对的内容。
内部类定义在局部时
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员，因为还有特有的外部中的引用。
但是不额可以王文它所在的局部中的变量，只能访问被final修饰的局部变量。