黑马程序员---java基础---面向对象2

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

面型对象

Day7

******1  继承概述

继承

        1.提高了代码的复用性。

         2.让类一类之间产生了关系，有了这个关系，才有了多态的特性。

注意

         千万不要为了获取其他类的功能，简化代码而继承。

         必须是类与类之间有所属关系才可以继承。所属关系式is a。

******2  继承概述

java语言

               java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患

             当多个父类中定义了相同的功能，但功能内容不同时，子类对象不确定要运行哪一个。

             但是java保留这种机制。并用另一种体现形式来完成表示。多实现。

             java支持多继承，也就是一个继承体系。

如何使用一个继承体系的功能呢？

         想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能。

         那么这个体系已经可以基本使用了。

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

         一：因为父类有可能不能建立对象。

        二：建立子类对象可以使用更多的功能，包括基本的也包括特有的。

        简单一句话：查阅父类功能，创建子类对象使用功能。

******3  聚集关系

1.聚合

            指的是整体与部分的关系。通常在定义一个整体类后，再去分析这个整体类的组成结构。
            从而找出一些组成类，该整体类和组成类之间就形成了聚合关系

2.组合

           也表示类之间整体和部分的关系，但是组合关系中部分和整体具有统一的生存期。
           一旦整体对象不存在，部分对象也将不存在。部分对象与整体对象之间具有共生死的关系。

******4 子类中变量的特点

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

类中成员
                变量、函数、构造函数

1.变量

          如果子类中出现非私有的同名成员变量时，

         子类要访问本类中的变量，用this

         子类要访问父类中的同名变量，用super

2.super

         super的使用和this的使用几乎一致

         this代表的是本类对象的引用。

         super代表的是父类对象的引用。

******5子类中函数的特点----覆盖

1.函数

           当子类出现和父类一模一样的函数时：

           当子类对象调用该函数，会运行子类函数的内容。

           如同父亲的函数被覆盖一样。

这种情况是函数的另一个特性：重写（覆盖）

         当子类继承父类，沿袭了父类的功能，到子类中。

         但子类虽具备该功能，但内容却和父类不一致，

         这时，没有必要定义新功能，而是使用覆盖特性，

        保留父类的功能定义，并重写功能内容。

2.覆盖

         1).子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

         2).静态只能覆盖静态。

3.注意重点

         重载：只看同名函数的参数列表

         重写：子父类方法要一模一样。

******6 子父类中构造函数的特点---子类实例化过程

1.子父类中的构造函数

           在对子类对象进行初始化时，父类的构造函数也会运行。

            因为子类构造函数默认第一行有一条隐式的super（）语句。

           super（）语句：会访问父类中空参数的构造函数。

           而且子类中所有的构造函数默认第一行都是super（）。

2.为什么子类一定要访问父类的构造函数？

         因为父类中的数据子类可以直接获取。所以子类对象在建立时，

         需要先查看父类是如何对这些数据进行初始化的。

        所以，子类在对象初始化时，要先访问以下父类中的构造函数。

        如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意：super语句一定定义在构造函数的第一行。

3.子类的实例化过程

    结论：

          1).子类所有的构造函数，默认的都会访问父类中空参数的构造函数。

              因为子类 每一个构造函数的第一行都有一句隐式的super（）

          2).当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。

          3).子类中的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。

             子类中至少会有一个构造函数会访问父类中的构造函数。

4.问题：

           1).为什么this和super不能同时在构造函数中

               因为 this和super语句都只能在第一行

           2).为什么要写在第一行

               因为初始化动作要在第一行

******7  final关键字

1.final：

          最终,作为一个修饰符

         1).可以修饰类、函数、变量

         2).被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

         3).被final修饰的方法不能被复写

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

             既可以修饰成员变量有可以修饰局部变量。当在描述事物时，一些数据的出现是固定的，

            那么这时为了增强阅读性，都给这些值起个名字。便于阅读。

            而这个值时不需要改变的，所以加上final修饰。

2.作为常量

           常量的书写方式规范所有的字母都大写，如果由多个单词组成。单词间通过  _  链接。

           public static final double PI = 3.14;

          public 权限足够大 ，可通过类名调用，静态共享

3.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

******8 抽象类

当多个类中出现相同功能，但功能主体不同，这时可以进行向上取。

这时，只抽取功能定义，而不抽取功能主体。

抽象类的特点：

1.抽象方法一定在抽象类中

2.抽象方法和抽象类都必须被abstract关键字修饰

3.抽象类不可以用new创建对象。因为调用抽象方法没意义。

4.抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

******9抽象类

抽象类与一般类没有太大不同

该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。

这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。通过抽象方法来表示。

抽象类比一般类多个抽象函数。就是在类中可以定义抽象方法。

抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

******10 抽象类练习

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 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("manager work");}}class pro extends Employee{pro(String name,String id,double pay){super(name,id,pay);}public void work(){System.out.println("pro work");}}class  AbstractTest{public static void main(String[] args) {pro p = new pro("lili","nanwa",210);                p.work();                Manager m = new Manager("kk","nnm",100,2);                m.work();}}

******11 模板方法模式

/* 需求：获取一段程序运行的时间 原理：获取程序开始和结束的时间，并相减 获取时间：用System.currentTimeMillis();当代码完成优化后，就可以解决这类问题。这种方式------模板方法设计模式什么是模板方法？在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而确定的部分在使用不确定的部分。那么此时就将不确定的部分暴露出去，由该类的子类去完成。*/abstract class getTime{public  final void GetTime()//此类中避免方法被重写，用final{  long start = System.currentTimeMillis();  runcode();      long end = System.currentTimeMillis();  System.out.println(end-start);}public abstract void runcode();}class runTime extends getTime{     public void runcode(){ for(int x=0;x<1000;x++) { System.out.print(x);      }}}class  TemplateDemo{public static void main(String[] args) {runTime t = new runTime();t.GetTime();}}

******12 接口 interface      （ implements实现）

/*接口：初期理解,认为是一个特殊的抽象类。      当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示class用于定义类interface用于定义接口接口定义是,格式特点：1.接口中常见定义:常量、抽象方法2.接口中成员都有固定修饰符  常量： public static final  方法： public abstract （ 默认会补全，但为良好的阅读性，应写全）   接口中的成员都是public的接口是不可以创建对象的，因为有抽象方法。需要被子类实现，*/interface Inter//也是一个类{public static final NUM = 3;public abstract void show();}class Test implements Inter{public void show(){}}class  InterfaceDemo{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);}}

******13继承

1.java支持多继承（有条件），但只有在接口之间能够实现多继承

           类和类之间只有单继承extends

           java的多继承由多实现来体现出来implements

           interface A {}

           interface B {}

            interface C extends A,B{}

           class Demo  {}

           class  test extends Demo implements  A,B {}

2.implements用法：

          接口实现的注意点：

                 a.实现一个接口就是要实现该接口的所有的方法(抽象类除外)。

                 b.接口中的方法都是抽象的。

                 c.多个无关的类可以实现同一个接口，一个类可以实现多个无关的接口。

3.extends与implements的不同

                extends 是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，
                也可以调用父类初始化 this.parent()。而且会覆盖父类定义的变量或者函数。
                这样的好处是：架构师定义好接口，让工程师实现就可以了。
                整个项目开发效率和开发成本大 大降低。

4.JAVA中不支持多重继承，但是可以用接口来实现，这样就要用到implements，

            继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了。
           实现父类，子类不可以覆盖父类的方法或者变量。即使子类定义与父类相同 的变量或者函数，也会被父类取代掉。 

5.格式：

              class A extends B implements C,D,E

              一个类通过关键字implements声明自己使用一个或者多个接口。
               在类的声明中，通过关键字extends来创建一个类的子类。 

              class 子类名 extends 父类名 implenments 接口名 

              {

              }

              若同时用到 extends 和 implements 的时候，extends 必须放在 implements 关键字之前。

******14接口的特点

1.接口是对外暴露的规则，是程序的功能扩展，可以用来多实现。

2.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

3.接口和接口之间可以有继承关系。

                                      ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------