Java基础-07

来源：互联网发布：悉尼大学金融硕士知乎编辑：程序博客网时间：2024/06/06 07:15

Java基础-面向对象

面向对象入门（续）

1、面向对象（继承描述）

例如：将学生和工人的共性描述提取出来，单独进行描述，只要让学生和工人与单独描述的这个类有关系，就可以了。

Eg：

class Person        //Person类，具有基本属性{    int age;    String name;}class Student extends Person        //Student类继承了Person类，具有了Person类基本的属性{    void study()    {        System.out.println("good study!");    }}class Worker extends Person     //Worker类继承了Person类，具有了Person类基本的属性{    void work()    {        System.out.println("good work!");    }}

继承：

（1）、提高代码的复用性。

（2）、让类与类之间产生了关系，有了这个关系，才有了多态的特性。

注意：千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承，所属关系is a。

2、面向对象（继承概述2）

Java语言中：java只支持单继承，不支持多继承，因为多继承容易带来安全隐患，当多个父类中定义了相同的功能，但内容不同，子类对象不确定要运行哪一个。其实Java这一机制是优化了C++语言。

以下是错误例子：

class A{    void show()    {        System.out.println("a");    }}class B{    void show()    {        System.out.println("b");    }}class C extends A,B{    public static void main(String [] args)    {        C c = new C();        c.show(); //由于多继承了A和B类，但是父类A和B中都有同样的方法，因而C类中的c对象不知如何执行方法。    }}

但是Java保留了另外一种机制，这种机制用另一种体现形式来完成表示，多实现。Java支持多层继承，也就是一个继承体系。
如何使用一个继承体系中的功能呢？

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能，那么这个体系已经可以基本使用了。

那么在具体调用时，要创建最子类的对象，为什么呢？

（1）、因为有可能父类不能创建对象。

（2）、创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单的说，就是查阅父类功能，创建子类对象使用功能。

3、面向对象（子父类中的变量特点）

子父类出现后，类成员的特点：

（1）、变量：如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this，子类要访问父类中的同名变量时，用super关键字去引用。Super的使用和this的使用几乎一致。this代表的是本类对象的引用。Super代表的是父类对象的引用。

Eg：

class Fu            //类fu{    int num = 4 ;}class Zi extends Fu     //类Zi继承类Fu{    int num = 5;    void show()    {        System.out.println(super.num);      //访问Fu类中的num值，用super引用    }}class ExtendsDemo{    public static void main(String []args)    {        Zi z = new Zi();        z.show();       //Zi类对象引用类中show方法    }}

输出结果：4

4、面向对象（子父类中函数的特点——覆盖）

当子类出现和父类一模一样的函数时，并且当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写（覆盖）

换句话说：当子类继承父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致。这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。

Eg1：class Fu            //Fu类，父类{    void show()        //方法show，打印内容    {        System.out.println("fu show");    }    void speak()        //方法speak，打印内容    {        System.out.println("VB");    }}class Zi extends Fu        //类Zi，继承父类Fu{    void show()        //方法show，打印内容，和父类Fu中的方法一样，引起覆盖机制    {        System.out.println("Zi show");    }    void speak()        //方法speak，打印内容，和父类Fu中的方法一样，引起覆盖机制    {        System.out.println("JAVA");    }}class ExtendsDemo{    public static void main(String[]args)    {        Zi z = new Zi();        //新建对象        z.speak();        //方法调用，引起子类功能覆盖父类功能        z.show();        //方法调用，引起子类功能覆盖父类功能    }}

程序结果：

JAVAZi show

覆盖：

（1）、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。（2）、静态只能覆盖静态。

注意记住：重载：只看同名函数的参数列表。重写：子父类方法要一模一样。

5、面向对象（子父类中构造函数的特点--子类实例化的过程）

（1）、子父类中的构造函数。在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数默认第一行有一条隐式的语句super(); super();会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();

（2）、为什么子类一定要访问父类中的构造函数呢？因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要访问一下父类中的构造函数，如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。但要注意：super语句一定要定义在子类构造函数的第一行。

（3）、子类的实例化过程子类的所有的构造函数，默认都会访问父类中的空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式的super();，当父类中没有空参数的构造函数时，子类必须要手动通过super语句形式来指定要访问父类中的构造函数，当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

Eg：class Fu{    Fu()            //父类Fu类中的构造函数，功能打印Fu run    {        System.out.println("Fu run");    }}class Zi extends Fu        //子类Zi类继承Fu类{    Zi()        //子类Zi类中的构造函数，功能打印Zi run    {        //super();        System.out.println("Zi run");    }    Zi(int x)        //子类Zi类中的构造函数重载，功能打印Zi... run    {        //super();        System.out.println("Zi..."+x);    }}class ExtendsDemo{    public static void main(String []args)    {        Zi z = new Zi();        //对象新建时子类中的构造函数都会默认访问Fu类中的构造函数        Zi z1 = new Zi(4);        //对象新建时子类中的构造函数都会默认访问Fu类中的构造函数    }}

程序结果：

Fu runZi runFu runZi...4

6、面向对象（final关键字）

final关键字：最终，作为一个修饰符

（1）、可以修饰类、函数、变量。（2）、被final修饰的类不可以被继承，为了避免被继承，被子类复写功能。（3）、被final修饰过的方法不可以被复写。（4）、被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些起个名字，方便于阅读，而这个值不需要改变，所以加上final修饰。（作为常量：常量的书写规范是所有字母都大写，如果由多个单词组成，单词间通过_连接）。（5）、内部类：定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

7、面向对象（抽象类）

抽象类：当多个类中出现相同功能，但功能主体不同，这是可以进行向上抽取，这时只抽取功能定义，不抽取功能主体。

抽象：即看不懂。

抽象类的特点：

（1）、抽象方法一定定义在抽象类中。（2）、抽象方法和抽象类必须被abstract关键字修饰。（3）、抽象类不可以用new创建对象，因为调用抽象方法没意义。（4）、抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

Eg：

abstract class Student            //抽象类{    abstract void study();        //抽象方法}class BaseStudent extends Student        //类BaseStudent继承抽象类，并方法覆盖抽象方法{    void study()    {        System.out.println("base study");    }}class AdvStudent extends Student        //类AdvStudent继承抽象类，并方法覆盖抽象方法{    void study()    {        System.out.println("adv study");    }}class AbstractDemo{    public static void main(String []args)    {        new Student();        //抽象类不可以用new创建对象，因为调用抽象方法没意义。所以编译失败。    }}

程序结果：编译失败。

8、面向对象（抽象类2）

抽象类：抽象类和一般类没有太大的不同，该怎么样描述事物，就如何描述事物，只不过该事物出现了一些看不懂的东西，这些不确定的部分，也是该部分的功能，需要明确出现，但是无法定义主体，通过抽象方法来表示，抽象类比一般类多个抽象函数，就是在类中可以定义抽象方法。特殊：抽象类中可以不定义抽象方法，而定义抽象方法仅仅是不让改类建立对象。

9、面向对象（抽象类练习）

//需求：假如我们在开发一个系统时需要对员工进行建模，员工包括了3个属性：姓名、工号以及工资，经理也是员工，除了含有员工的属性外，另外还有一个奖金属性，请使用继承的思想设计出员工类和经理类，要求类中提供必要的方法进行属性访问。

//员工类：name、id、pay //经理类：继承了员工，并有自己特有的bonus

Eg：

abstract class Employee        //抽象类Emoloyee，员工类{    private String name;    private String id;    private double pay;    Employee(String name,String id,double pay)          //构造函数给Employee属性赋值    {        this.name = name ;        this.id = id;        this.pay = pay;    }    public abstract void work();            //抽象方法}class Manager extends Employee        //Manager类继承了Employee类，经理类{    private int bonus;            Manager(String name,String id,double pay,int bonus)        //构造函数初始化    {        super(name,id,pay);        this.bonus = bonus;    }    public void work()            //实现抽象类中的抽象方法    {        System.out.println("Manager work");    }}class Pro extends Employee        //Pro类继承了Employee类{    Pro(String name,String id,double pay)        //构造函数初始化    {        super(name,id,pay);    }    public void work()        //实现抽象类中的抽象方法    {        System.out.println("Pro work");    }}

10、面向对象（模板方法模式）

//需求：获取一段程序运行时间 //原理：获取程序开始和结束的时间并相减即可。获取时间：System.currentTimeMillis();

class GetTime{    public void getTime()    {        long start = System.currentTimeMillis();        //获取时间        for(int x = 0;x<1000;x++)        //运行一段程序        {            System.out.print(x);        }        long end = System.currentTimeMillis();    //for循环结束后再次获取一次时间        System.out.println();        System.out.println("毫秒："+(end-start));    //前后两次时间相减并输出    }}class GetTimeDemo{    public static void main(String[]args)    {        GetTime t = new GetTime();        //建立对象        t.getTime();            //调用方法    }}

Eg2(程序改进：子类复写)：

abstract class GetTime        //把原来的一般类改写成抽象类{    final public void getTime()        //不让子类复写，加上final    {        long start = System.currentTimeMillis();        //获取时间        runcode();                //调用runcode方法        long end = System.currentTimeMillis();    //for循环结束后再次获取一次时间        System.out.println();        System.out.println("毫秒："+(end-start));    //前后两次时间相减并输出    }    abstract public void runcode();        //把runcode定义成抽象方法，给子类复写}class SubTime extends GetTime        //子类继承父类{    public void runcode()        //子类可以复写父类中的runcode抽象方法，控制程序运行时间。    {        for(int x = 0;x<1000;x++)        //运行一段程序        {            System.out.print(x);        }    }}class GetTimeDemo{    public static void main(String[]args)    {        SubTime t = new SubTime();        //建立对象        t.getTime();            //调用方法    }}

当代码完成优化后，就可以解决这类问题。这种方式：模板方法设计模式

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

11、面向对象（接口）

接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。 class用于定义类，而interface用来定义接口。接口在定义时，格式特点：

（1）、接口中常见定义：常量，抽象方法。（2）、接口中的成员都有固定的修饰符。

常量：public static final 方法：public abstract

记住：接口中的成员都是public的。 Eg：

interface Inter        //接口Inter{    public static final int Num = 3;    public abstract void show();}class Test implements Inter    //子类实现Inter接口，implements是实现关键字{    public void show(){}        //子类需要把接口中的抽象方法覆盖了，子类才能实例化}class TestDemo{    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);    }}

输出结果：

注意：接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部都覆盖后，子类才可以实例化，否则子类是一个抽象类。

12、面向对象（接口2）

接口可以被类多实现，也是对多继承的一个转换形式。

interface Inter        //接口Inter{    public static final int Num = 3;    public abstract void show();}interface InterA        //接口InterA{    public abstract void show();}class Demo        {    public void function(){}}class Test extends Demo implements Inter,InterA       //Test类继承Demo类的同时实现接口Inter和InterA，多继承的一个转换形式{    public void show(){}        //子类覆盖接口方法}class InterfaceDemo{    public static void main(String[]args)    {        Test t = new Test();        System.out.println(t.Num);        System.out.println(Inter.Num);        System.out.println(Test.Num);    }}