首页 > 代码库 > Java学习-第三天
Java学习-第三天
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修饰的局部变量。
Java学习-第三天