day09_面向对象(继承+抽象+接口)

面向对象(继承-子父类中的构造函数-子类的实例化过程)

面向对象(继承-子父类中的构造函数-子类的实例化过程-细节

 

 

/*

子父类中的构造函数的特点。

 

在子类构造对象时，发现，访问子类构造函数时，父类也运行了。

为什么呢？

原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();

 

子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。

   

           

为什么子类实例化的时候要访问父类中的构造函数呢？

那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，

要先看父类是如何对自己的内容进行初始化的。

 

所以子类在构造对象时，必须访问父类中的构造函数。

为什么完成这个必须的动作，就在子类的构造函数中加入了super()语句。

 

如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用

父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，

那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。

但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

 

 

注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。

*/

 

class Fu

{

    int num ;

    Fu()

    {

        num =10;

        System.out.println("A fu run");

    }

    Fu(int x)

    {

        System.out.println("B fu run..."+x);

    }

}

class Zi extends Fu

{

    int num;

    Zi()

    {

        //super();//调用的就是父类中的空参数的构造函数。

       

        System.out.println("C zi run"+num);

    }

    Zi(int x)

    {

        this();

        //super();

//      super(x);

        System.out.println("D zi run "+x);

    }

}

 

class  ExtendsDemo4

{

    public static void main(String[] args)

    {

        new Zi(6);

    }

}

class Demo//extends Object

{

    /*

   

    Demo()

    {

        super();

        return;

    }

    */

}

面向对象(继承-子父类中的构造函数-子类的实例化过程-图解)

 

class Fu

{

    Fu()

    {

        super();

        show();

        return;

    }

 

    void show()

    {

        System.out.println("fu show");

    }

}

class Zi extends Fu

{

    int num = 8;

    Zi()

    {

        super();

        //-->通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后，

        //才进行子类的成员变量显示初始化。

 

        System.out.println("zi consrun...."+num);

        return;

    }

    void show()

    {

        System.out.println("zi show..."+num);

    }

}

class ExtendsDemo5

{

    public static void main(String[] args)

    {

        Zi z = new Zi();

        z.show();

    }

}

上面这个main函数的执行结果:

Zi show......0

zi cons run....8

zi run.... 8

 

/*

一个对象实例化过程：

Person p = new Person();

1，JVM会读取指定的路径下的Person.class文件，并加载进内存，

    并会先加载Person的父类(如果有直接的父类的情况下).

2，在堆内存中的开辟空间，分配地址。

3，并在对象空间中，对对象中的属性进行默认初始化。

4，调用对应的构造函数进行初始化。

5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。

6，父类初始化完毕后，在对子类的属性进行显示初始化。

7，在进行子类构造函数的特定初始化。

8，初始化完毕后，将地址值赋值给引用变量.

 

*/

对于成员变量而言有默认初始化值，对于final呢并不是默认初始化，而是显示初始化

注意:一旦一个数据每个对象都一样，不需要改的话也，就静态化一般都会加静态

static final int x = 7;

//继承弊端：打破了封装性。

/*

final关键字：

1，final是一个修饰符，可以修饰类，方法，变量。

2，final修饰的类不可以被继承。

3，final修饰的方法不可以被覆盖。

4，final修饰的变量是一个常量，只能赋值一次。

    为什么要用final修饰变量。其实在程序如果一个数据是固定的，

    那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。

    而且这个变量名称的值不能变化，所以加上final固定。

    写法规范：常量所有字母都大写，多个单词，中间用_连接。

*/

 

 

抽象类-概述

自己理解抽象:就是这类事物都具备这个功能，但是这个具体内容都不知道，，，，没有足够的信息来描述这个信息，这个类就是抽象类,功能细节无法确定所以就抽象出来就是抽象方法

 

抽象类的由来:其实也是不断的向上抽取来的，越往上抽取就越不具体，不具体就出现抽象类，就是每个类的功能都有，但是实现方式不一样

抽象类：

抽象：笼统，模糊，看不懂！不具体。

 

 

 

特点：

1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。

    抽象方法必须定义在抽象类中。该类必须也被abstract修饰。

2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。

    没有意义的解释:那个方法没有方法体，无法去运行,所以没有必要调用，这就是没有意义的原因

3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。

    否则，这个子类还是抽象类。

abstract class Demo

{

    abstract /*抽象*/ void show();

   

}

class DemoA extends Demo

{

    void show()

    {

        System.out.println("demoashow");

    }

}

class DemoB extends Demo

{

    void show()

    {

        System.out.println("demobshow");

    }

}

 

面向对象(抽象类-细节)

1，抽象类中有构造函数吗？

    有，用于给子类对象进行初始化。

    为什么会有也:构造函数除了给本类的成员变量进行初始化以外，还可用于给父（子）类对象进行初始化:

 

   

2，抽象类可以不定义抽象方法吗？

    可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。

    通常这个类中的方法有方法体，但是却没有内容。

 

    abstract class Demo

    {

        void show1()

        {}

        void show3();这个名称叫做没有方法体

 

        void show2()

        {}这个叫做有方法体但是没有内容

    }

 

3，抽象关键字不可以和那些关键字共存?

    private 不行原因:

 抽象方法是不是要被覆盖，你这一私有子类就不知道，就不能覆盖

    static 不行

如果成员变静态，就不需要对象，抽象类正好不用创建对象吗，我不需要对象你干吗要创建啊，我直接类名就调用这个方法了，抽象方法运行有意义吗，没有意义，连方法体都没有，做什么运算都不知道,所以也不能共存

    final  不行

final在继承中又是不是覆盖的，然儿也定义抽象方法就又是用来覆盖的

 

 

4，抽象类和一般类的异同点。

    相同点：

        抽象类和一般类都是用来描述事物的，都在内部定了成员。

    不同：

        1，一般类有足够的信息描述事物。

           抽象类描述事物的信息有可能不足。

        2，一般类中不能定义抽象方法，只能定非抽象方法。

           抽象类中可定义抽象方法，同时也可以定义非抽象方法。

        3，一般类可以被实例化。

           抽象类不可以被实例化。

5，抽象类一定是个父类吗？

    是的。因为需要子类覆盖其方法后才可以对子类实例化。

 

面向对象(抽象类-练习)

需求:

雇员示例：

需求：公司中程序员有姓名，工号，薪水，工作内容。

项目经理除了有姓名，工号，薪水，还有奖金，工作内容。

对给出需求进行数据建模。

分析:这个时候使用名词提炼法，这时候时候你说有公司，对象是用来封装数据的，公司没有数据吧，所以也不用创建对象

分析：

在这个问题领域中，先找出涉及的对象。

通过名词提炼法。

程序员：

    属性：姓名，工号，薪水、

    行为：工作。

经理：

    属性：姓名，工号，薪水，奖金。

    行为：工作。

 

 

程序员和经理不存在着直接继承关系，因为经理并不是程序员的一种，

 

有共性内容就进行向上抽取

 

但是程序员和经理却具有共性内容。

可以进行抽取。因为他们都是公司的雇员

 

可以将程序员和经理进行抽取.建立体系.

   

*/

 

//描述雇员。

 

abstract class Employee

{

    private String name;

    private String id;

    private double pay;

    Employee(String name,String id,double pay)

    {

        this.name = name;

        this.id = id;

        this.pay = pay;

    }

 

    public abstract void work();

   

}

 

 

//描述程序员。

class Programmer extends Employee

{

    Programmer(String name,String id,double pay)

    {

        super(name,id,pay);

    }

    public void work()

    {

        System.out.println("code...");

    }

}

 

//描述经理。

class Manager extends 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("manage");

    }

}

class  AbstractTest

{

    public static void main(String[] args)

    {

        System.out.println("Hello World!");

    }

}

 

小知识点总结一下

Class Demo

{

void show()

{

System.out.println("demo show");

}

}

Class DemoA extends Demo

{

void show()

{

System.out.println("demo show");

}

}

Class DemoB extends Demo

{

void show()

{

 System.out.println("demo show");

}

}

上面这个也是我们之前学的继承，去发现事物之间的关系，并向上进行抽取，

这里有一个一问题:DemoA和DemoB确实有相同的内容，但是也内容却不一样，这个时候就使用了抽象，你如果说是你直接是覆盖话也，子类也可以重写这里面的方法，但是也那个这个父类的这个方法存在就没有意义，所以也就定义抽象，定义抽象也是这个子类必须有这些功能的 ，具体是什么内容就让子类去实现,我是这么理解的，这里面我还是一个疑问也

 

 

面向对象(接口-定义interface)

/*

abstract class AbsDemo

{

    abstract void show1();

    abstract void show2();

}

 

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用

另一种形式定义和表示，就是 接口 interface。

*/

 

//定义接口使用的关键字不是class，是interface.

/*

对于接口当中常见的成员：而且这些成员都有固定的修饰符。

1，全局常量:public  static final

 

2，抽象方法。publicabstract

 

由此得出结论，接口中的成员都是公共的权限.

为什么是公共的权限的也:

因为要被子类覆盖吗，所以也权限也最大

 

*/

interface Demo

{

    public static final int NUM = 4;

 

    public abstract void show1();

    public abstract void show2();

}

 

面向对象(接口-实现implements

 

下面是讲解继承与实现的区别:

我继承对于抽象类来讲，它有些内容是不抽象的，是不是子类可以直接拿来用的，这就是实现与继承的区别：实现就是你这里面有的我都得去覆盖

 

interface Demo

{

    public static final int NUM = 4;

 

    public abstract void show1();

    public abstract void show2();

}

//类与类之间是继承关系，类与接口直接是实现关系。

/*

接口不可以实例化。

 

只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。

否则，这个子类就是一个抽象类。

 

*/

 

 

class DemoImpl implements /*实现*/Demo

{

    public void show1()

    {}

 

    public void show2()

    {

   

    }

}

 

面向对象(接口-多实现  好处

/*

在java中不直接支持多继承，因为会出现调用的不确定性。

所以java将多继承机制进行改良，在java中变成了多实现。

 

一个类可以实现多个接口。

 

*/

说明一下:我继承的目的是什么，就是为了提高子类的功能，那么如果说多继承有好处的话也，例如，一个类的ab两个方法，另外一个类有cd两个方法，我让一个类去继承这两个方法是不是就有了这四个方法也，现在定义接口也，也是一个接口里面定义ab两个方法，另外一个接口是定义cd两个方法，那我用一个具体类去实现这两个接口也同时有了四个方法，那他们之间有什么区别呢：我们说一下，我们注重的是这个事物应该具备的功能，至于这个功能该怎么用，由子类来明确 ，如果子类认为父类中的这个功能已经符合我的需求了，是不是真接拿来用啊，如果不符合我的需求，那是不是还要有一个功能，就是重写啊，只不过接口是必须要你重写而已，这个接口里面cd两个功能一实现这个接口就意为着，你这类事物具备了cd两个功能，至于cd怎么去运作，是不是由子类说了算啊,看看多实现是怎么体现的

 

interface A

{

    public void show();

}

interface Z

{

    public void show();

}

class Test implements A,Z//多实现

{

public void show();

}

Test test = new Test();

test.show()

这里面说一多继承与多实现的具体点的区别:

多继承如果去实现上面的话也，会出现在调用不确定性，为什么会现在这种情况也不确定性也，因为多继承它的方法有方法体，正因为有方法体，才导致运行的结果不一样,这就是多实现的好处

多实现也不会出在不确定性，这个show方法给上面两个都覆盖了

 

 

/*

在java中不直接支持多继承，因为会出现调用的不确定性。

所以java将多继承机制进行改良，在java中变成了多实现。

 

一个类可以实现多个接口。

 

*/

 

interface A

{

    public void show();

}

 

interface Z

{

    public int add(int a,int b);

}

class Test implements A,Z//多实现

{

   

    public int add(int a,int b)

    {

        return a+b+3;

    }

    /**/

    public void show(){}

   

}

面向对象(接口-细节)

 

/*

一个类在继承另一个类的同时，还可以实现多个接口。

 

 

 

*/

class Q

{

    public void method()

    {}

}

 

abstract class Test2 extends Q implements A,Z

{

 

}

/*

接口的出现避免了单继承的局限性。

 

*/

 

 

interface CC

{

    void show();

}

interface MM

{

    void method();

}

 

interface QQ extends  CC,MM//接口与接口之间是继承关系，而且接口可以多继承。

{

    void function();

}

这里面为什么支持多继承也，多继承差就差在方法体上，接口没有方法体，所以也就没事

 

别人以后再问你说，java支持多继承吗，你说支持啊： 只不过多继承在类进行了改良，用多实现的方式来进行体现的，但是接口内容的出现却可以进行多继承 ，原理就在于方法体是否有存在，类不支持多继承不就是因为有方法体调用的不确定性吗

 

 

 

 

面向对象(接口-特点

说一个例子：

就是笔记本电脑的这个接口，早期的笔记不是这样的，它原来是封装好了的，对外提供了接口

 

-面向对象(接口和抽象类的区别

 

/*

抽象类和接口的异同点：

 

相同点：

    都是不断向上抽取而来的。

 

 

不同点：

    1，抽象类需要被继承，而且只能单继承。

       接口需要被实现，而且可以多实现。

    2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。

       接口中只能定义抽象方法，必须由子类去实现。

    3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。

      Is a 就是所属关系，什么是什么的一种，

       接口的实现是like a 关系，在定义体系额外功能。

  

就是举个例子，学员啊学员有学习功能吧，没有抽烟功能，学习是学员的基本功能吧，抽烟不是，抽烟是不是学员的额外功能啊，那些学员抽烟就去实现这个抽烟接口呗

 

 

 

 

犬按功能分：有导盲犬，搜爆犬。

 

 

abstract class 犬

{

    abstract void 吼叫();

}

 

//abstract class 导盲

interface 导盲

{

    abstract void 导盲();

}

 

 

class 导盲犬extends 犬 implements 导盲

{

    public void 吼叫()

    {

    }

    public void 导盲(){}

}

 

 

 

//在不同的问题领域中，有不同的分析方式。

学员：

    学习。

    抽烟学员

 

 

 

 

烟民。

   

 

*/

 

class InterfaceDemo

{

    public static void main(String[] args)

    {

        System.out.println("Hello World!");

    }

}

 

面向对象(接口的应用

广意的来说，对外提供的我们就称为接口

例子还是以笔记本为例子讲

/*

笔记本电脑使用。

为了扩展笔记本的功能，但日后出现什么功能设备不知道。

 

定义一个规则，只要日后出现的设备都符合这个规则就可以了。

规则在java中就是接口。

 

*/

interface USB// 暴露的规则。

{

    public void open();

    public void close();

}

 

 

class BookPC

{

    public static void main(String[] args)

    {

        useUSB(new UPan());//功能扩展了。

        useUSB(new UsbMouse());

    }

 

    //使用规则。

    public static void useUSB(USB u)//接口类型的引用，用于接收(指向)接口的子类对象。//USB u=new UPan();

    {

        if(u!=null)

        {

            u.open();

            u.close();

        }

    }

}

//一年后。------------------------------

//实现规则。

 

//这些设备和电脑的耦合性降低了。

 

class UPan implements USB

{

    public void open()

    {

        System.out.println("upan open");

    }

    public void close()

    {

        System.out.println("upan close");

    }

 

}

 

 

class UsbMouse implements USB

{

    public void open()

    {

        System.out.println("UsbMouse open");

    }

    public void close()

    {

        System.out.println("UsbMouse close");

    }

 

}

 

 

 

 

 

 

 

 

/*

class Mouse

{

}

 

class BookPC

{

    public static void main(String[] args)

    {

        useMouse(new Mouse());

    }

    public static void useMOuse(Mouse m)

    {

        m.open();

    }

    public static void useMOuse(Mouse m)

    {

        m.open();

    }

}

*/