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、内部类可以直接访问外部类中的成员，包括私有.原因是内部类中持有外部类的引用： 外部类名.this2、外部类要访问内部类，必须建立对象访问格式：
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修饰的局部变量。