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修饰的局部变量。

posted on 2014-10-12 10:25 编程小兵阅读(881) 评论(0) 编辑收藏举报

刷新页面返回顶部

公告