学习Java的第三周

 什么是封装？

            一个类中的成员变量需要对外隐藏，被private修饰，为了保证数据安全性：对

外需要提供公共的访问方法setXXX()赋值/getXXX()获取值。

        什么是匿名对象？

            标准写法：

                    类名  对象名=new  类名();

                匿名对象的格式

                        new类名():直接在堆内存开辟空间，使用完毕就要被回收，可以节省内存

               匿名对象的好处：

                        1）匿名对象可以作为参数传递

                        2）匿名对象可以节省内存空间，因为压根没有栈内存空间，不需要开辟

                                直接开辟堆内存空间

                        3）匿名对象一般适用于一次即可，使用完毕，直接被JVM的GC（垃圾                                回收器 ）回收

        this关键字的概念及目的

                this  :代表当前类对象的地址值的引用  Student s=new Student();

                                    s--->空间地址值的引用

                this 的出现： 为了防止局部变量隐藏了成员变量

                this的用法：

                            this.变量名：变量名：访问本类的成员变量名

                            this.方法名();访问的本类的成员方法       

                            this.()-----访问本类的无参构造方法    

                            this(xxx)   访问本类的有参构造方法

        构造方法的特点以及注意事项：

                特点：

                    1）方法名和类名相同。  2）没有具体返回值类型。3）连void都没有

                        public 方法名和类型相同(){

                                }

                构造方法的目的：就是为给类的成员初始化

                        举例：

                                Phone p=new phone();

                1)栈内存开辟空间。2）堆内存申请空间。3）进行系统默认化，为成员变量

                4）setXXX("xxx")有参构造方法：显示初始化。

                构造方法的注意事项：

                1）当在书写一个标准的类的时候，没有给出任何构造方法，系统会默认提供                        无参构造方法

                2）如果提供了一个类的有参构造方法，系统就不会提供默认的构造方法，所                        以减一永远给出无参构造方法

                3）构造方法是可以重载的。

    一个类的组成一个类的标准写法

                一个类的组成

                        1 ）成员变量。2)构造方法。3）成员方法

            一个类的标准类的写法：

            1）成员变量私有化。

            2）无参永远给出，有构造根据题意要求

            3）成员方法，根据题意要救

static关键字的特点：

    static关键字的特点:

         1)被静态修饰的随着类的加载而加载,优先于对象存在;

          2)不能和this共存;

          3)本身含义就是共享,共用;可以多个对象共享共用;

                  这也是告诉我们,什么将某个属性定义static

                 举例: 饮水机的水----共享,共用

                      自己水杯中的水---不行的

                    或者说:三个窗口同时出售100张电影票,  100张票被三个窗口共用;

          4)被静态修饰的成员变量或者成员方法(静态变量/静态方法) (掌握)

                  访问的方式:

                      可以使用对象名来访问 但是,对于系统来说(jvm)静态的东西:变量/方法 都是类名直接访问;

                      类名.变量名;

                      类名.方法名()

                    静态方法中只能访问静态变量

                    静态方法只能调用静态方法;

                    非静态方法皆可以访问静态的东西也可以访问非静态的东西;

     代码块:     

                使用{}括起来的内容分类:

                  局部代码块,就是在方法定义中使用{}

                    {},作用:就是限定局部变量的生命周期;

           构造代码块:---在类的成员位置定义的{},它有特点:在执行构造方法之前,如果类中                有构造代码块,

           优先执行构造代码块,作用:也可以给类的成员的数据进行初始化; (实际开发很少                 见到构造代码块)

           只要执行构造方法,如果存在构代码块,它必须优先执行,然后才是构造方法...

         静态代码块:

         类就加载一次,静态代码块也就执行一次!

              格式

                      static{ --->跟静态相关的都和类有关系,随着类的加载而加载;

                          里面书写代码

                      }

                     静态代码块,构造方法,构造代码块

                     优先级:静态代码块 > 构造代码块> 构造方法,而且每次执行构造方法之前,优先执行所有的构造构造代码块

     继承 extends

        继承:

               将多个类的共性内容抽取出来,放在一个独立的类中,让这个独立的类和其他类产生一种关系

                "继承"---关键字 extends

             格式:

                  class 父类名{

                     共性内容:姓名,年龄.....

                     提供公共的访问方法setXXX()/getXXX()

                 }

                  class 子类名 extends 父类名{}

          继承的好处:

              1)可以提高代码复用性

              2)可以提高代码的维护性,后期便于维护,针对子类和父类进行维护(子父关系明确)

              3)类与类产生的继承关系,是后面讲"多态"的前提条件;

              在Java中有一个开发原则 "低耦合,高内聚"(以后所有的Java设计模式都需要遵循这一个原则)

              耦合性:开发中是永远避免不了,可以降低(耦合:类和类的关系)

              内聚性:指的是某个类完成某个功能的一种能力; 尽量不要产生继承关系来完成一个功能,一个类能完成一个类完成;

              低耦合:降低耦合性,减少类和类的关系;

      继承的特点:

          1)在Java语言中,类和的类的关系是一种继承关系,这个继承只能支持"单继承",不支                持多继承

                  class 父{}

                  class 父2{}

                  class 子 extends 父,父2{} 多继承:不支持

                   class 子 extends 父{} ：正常的语法格式

          2)类和类关系,虽然不支持多继承,但是层层单继承----> 多层继承

    关于的注意的问题:

      1.子类继承父类,对于非私有的成员,直接可以继承过来,但是如果私有成员,它可以通过                公共的访问可以访问,但是直接访问的;

      2.被私有修饰的东西(成员变量/成员方法),只能在当前类访问的;

    在继承关系中,构造方法的访问问题(重点)

      子类继承父类,子类的所有构造方法都默认访问父类的无参构造方法

    继承关系中成员变量的访问问题：

        子类继承父类，如果子类的成员变量名称和父类的成员变量名称不一致，分别访问即可”

    如果子类的成员变量和父类的成员变量名称一直：

    1）先在子类的局部位置找，是否存在，存在，就使用；

    2）如果子类的局部变量位置没有，在子类的成员位置找，是否存在，存在就使用；

    3）如果子类的成员位置也没有，然后再父类的成员位置找，是否存在，存在就使用;

    4）如果父类的成员位置也没有，（父类没有它的父类），就报错，整个类中没有变量

        遵循“就近原则”

    继承关系中成员方法的访问问题：

        子类继承父类，成员方法（公共方法）名称不一致，分别调用就可；

如果成员方法名一样，系统认为子类需要重写父类的方法，必须保证子类的方法和父类一模一样

--------子类将父类的方法覆盖，方法重写，访问子类的功能

修饰词Final：

    最终的，无法更改的，状态修饰符，被final修饰的成员方法，不能被重写，保证父类的方法安全性！

    final关键字特点:

          本身的含义:最终的,无法更改的

            1)final可以修饰类,该类不能被继承

            2)final可以修饰变量,此时这个变量是一个"常量",常驻内存;

多态

什么是多态?

 多态:

      宏观角度(现实生活中):一个事物在不同时刻体现的不同形态

      水事物:

              气态,固态,液态

       猫是动物

       狗是动物

       微观角度(内存中变化):具体对象在内存中的变化(对象在不同时刻的类型)

   多态的前提条件 (重点)

          1)必须有继承关系(类与类),没有继承关系,不谈多态!

          2)必须存在方法重写,子类部分功能要将父类的功能进行覆盖,重写,子类使用自己的功能体现;

3)必须存在父类引用指向 子类对象

    多态成员的访问特点：

            1）成员变量：编译看左，运行看左

            2）成员方法：编译看左，运行看右，存在方法重写

            3）静态的方法：算不上重写，跟类相关的，编译看左，运行看左

            4）构造方法：分层初始化，先执行父类初始化，在执行子类初始化

    多态的弊端:

          1)有继承关系了 2)有重写了 3)有父类引用指向子类对象 Fu f = new Zi() ;

          无法调用子类的特有功能!

          如何解决呢?

              方案1:创建自己的子类对象

                  子类名 对象名 = new 子类名() ;

                  方案1不好地方:本身Fu fu = new Zi() ;已经开辟堆内存空间了,

                              Zi zi = new Zi();又要在堆内存开辟空间,消耗内存空间比较大 ;

              方案2: 多态的第三个前提条件:父类引用指向子类对象

                  能不能将 将父类的引用 强制为子类的引用呢?

                  可以:

                  向下转型

                         前提必须向上转型Fu fu = new Zi() ;

                         Zi z  = (Zi)fu ;  //强转的语法

                         这样的好处:节省内存空间

    多态的好处：

            1）提高代码的复用性，有继承保证的

            2）提高代码的扩展性，由多态保证：父类引用指向子列对象

instaceof：关键字：

        格式：一般用于判断场景用的：

            if（变量名  instanceof 引用类型数据类型（多态））{}判断前面这个变量名是否

为指定的数据类型（堆内存中的变化）true“表示是指定的类型；false：不是指定的类型

            if（a instanceof Cat） {

                System.out.println("是cat类型");

            }else{

                System.out.println("不是cat类型")；

                }

运行时期异常--->java.lang.ClassCastException  :类转换异常 一般都出现多态里面向下转型使用不当就会造成这个异常出现

抽象：

     什么是抽象类?

          在一个类中,如果有抽象方法,这个类必须为抽象类

给某个事物的一些行为,不给出具体体现,在Java编程中,应该加入一个关键字 abstract,这些行为--->"抽象方法"

           有抽象方法的类一定是抽象类,否则编译就会报错!

           抽象类中一定都是抽象方法吗?  不一定,抽象类中可以存在抽象方法,也可以存在具体方法

        抽象的方法的格式:

                  根据写方法的格式一样,加入一个关键字abstract,而且没有方法体{}

                  public abstract 返回值类型 方法名(空参/带参) ;

      抽象类的特点:

              1)不能实例化 (不能创建对象)

              2)必须强制子类完成事情:必须将抽象方法重写!

      抽象类的子类:

                  如果子类是一个抽象类,  没有意义(抽象类new不了) (前提条件是这个子类没有它的子类)

                 研究的抽象类的子类一定会有一个具体类,这个时候通过具体类才能创建对象;

                 抽象的父类名  对象名  = new 具体的子类名() ;  抽象类多态

抽象类的成员特点:

      成员变量:抽象类的成员变量既可以有变量,也可以是自定义常量被final

      成员方法:抽象类中既可以有抽象方法,也可也有非抽象方法

      构造方法:

              既可以定义无参/有参构造方法...

          存在抽象类多态,有继承关系,初始化的时候,构造方法----分层初始化---->先父类初始化,子类初始化

接口：

        什么是接口?

      接口体现的是事物的一种额外功能 ;

      设计理念:  体现的是一种  "like a"的关系

                  跳高猫

                  钻火圈狗

      之前讲继承的概念--->设计理念体现的是一种"is a"的关系 :什么是什么的一种

Java编码中,体现这些事物本身不具备的功能,要经过一些特殊的实现才能具备功能-----称为 "接口"---关键字 interface

         格式的写法

                  interface  接口名{   //命名规范和类名命名一样,见名知意 "大驼峰命名法"

                          只能为抽象方法

                  }

                 接口的子类----"子实现类"

                              实现

                 class 子类名  implements  接口名{

                 //接口比抽象类还抽象----> 特点:不能实例化                  

                  }

如何实例化?

  接口通过它的子实现类进行实例化(前提,这个类实现 implements 接口)

  class 子实现类名 implements 接口名{//实现

  }

  实际开发中:接口的子类实现类名的命名---> 接口名的后面+Impl:表示是接口的实现类

  接口的成员特点:

          1)成员变量:只能是常量,存在默认修饰符 :public static final

          2)成员方法:只能是抽象方法,存在默认修饰符  public abstract

          3)构造方法:没有构造方法的---通过子实现类的构造方法来实例化

          接口本身意义:对外暴露这些功能,让子实现类实现 !