面向对象oo

数据类型 引用类型变量     指向                 对象 

Student                zs            =             new Student();

方法签名:方法名+参数列表

重载 (overload)：

              1.在同一个类中，方法名相同，参数列表不同。与返回值类型，变量名称无关

               2.编译器在编译时会根据方法的签名自动绑定方法

构造方法：构造函数，构造器，构建器-----------复用给成员变量赋初值始代码

        也属于类中成员，可以用四种修饰符来修饰

作用： 1.给成员变量赋初始值

            2.与类同名，没有返回值类型（连void都没有）

            3.在创建（new）对象时被自动调用

            4.不写默认给一个无参构造，写了就不给无参构造

            5.构造方法可以重载

了解:

1.this：只能在方法中，方法中访问成员变量之前默认有个this       

               指代当前对象，哪个对象调用方法它指的就是哪个对    

               例如： zs.study（）；-----study（）中this指的是zs

2.     this.方法名()-------调用方法

        this（）-------------调用构造方法   且只能用在构造方法里面，且只能在第一行

3.null:表示空,没有指向任何对象，若引用的值为null，则该应用不能进行任何点操作了，若操作则发生NullPointException

4.引用类型数组:

        1)Bomb[ ] bs = new Bomb[3];

        bs[0] = new Bomb(100,200); new后面的Bomb依据于上面的bs中括号左边的类型

bs[0]初始默认值为null，new之后就存了Bomb对象地址

        2)访问对象的属性和方法

        bs[0].x= 111;

 可以点出来的都是依据bs左边的数据类型

继承:extends       派生类/子类  extends  超类/父类

        作用：代码复用

        一个超类可以有多个派生类                                       

        一个派生类只能有一个超类-----------单一继承

        超类只能访问自己的，不能访问派生类。

        派生类可以访问超类

        具有传递性

        补充：要符合is a的关系  派生类is  a  超类

         java规定:构造派生类之前必须构造超类

        *若派生类中的构造方法中没有调用超类的构造方法，则默认super()调用超类的无参构造方法

        *派生类的构造方法中若自己调用了超类的构造方法，则不再默认提供

         *super()调用超类构造方法，必须位于派生类构造方法的第一行

补充：泛化:将共有的抽出来的过程，设计层面（泛化），代码实现上(继承)，

==泛化就是继承

super:指代当前对象的超类对象

super用法：

  super用于访问当前对象的超类

       super.成员变量名----------了解

        super.方法名()---------------调用超类的方法

       super()-------------------------调用超类的构造方法    

this：当前对象

向上造型:

        超类型的对象指向了派生类的的对象

   ****能点出来什么，看引用的类型（对象名左边的）---------规定

超类型               派生类型

Animal o = new Tiger();//向上造型   只能点出Animal的

Person p = new Student();                只能点出Person的

要符合:

超类  指向  派生类

派生类 is a 超类

重写:override 覆盖

        发生在父子类中，方法名相同，参数列表相同

         

当派生类觉得超类的行为不够好时，可以重写

***重写方法被调用时，看对象的类型  (new出来的才是对象)

***遵循两同两小一大

1.两同 

        1）方法名相同

        2）参数列表相同

2.两小

        1）派生类的方法返回值类型必须小于或等于超类方法的

               1.1） void和基本类型时必须一样

               1.2）引用类型时，小于或者等于     父类大，子类小

       2）  派生类方法抛出的异常方法必须小于或等于超类方法的

3.一大

        派生类的方法访问权限必须大于或等于超类方法的

package：声明包

        作用：避免类的命名冲突

        同包中的类不能同名，不同包中类可以同名

        类的全称

        建议：包名都小写

        package声明必须位于第一行

import ：

        同包中的类可以直接访问，不同包的类需要import

访问控制修饰符:

       ------------ 保护数据的安全

        public:                                                               任何类

        private:                            本类

        protected:受保护的，     本类，同包类,派生类

        默认的：                         本类，同包类      ------------java不建议

类中成员（属性，方法）：四种都行

类：只能为public，默认

  封装的意义：保护数据的安全

        数据（成员变量）私有化(private)

        行为（方法）公开化(public)

static:

静态变量：

                static修饰

                属于类，存储在方法区中，只有一份

                通过类名来点来访问

                何时用：对象为共享的数据（图片，音频，视频等）

静态方法：

                static修饰

                属于类，存储在方法区中，只有一份

                通过类名来点来访问

                静态方法没有隐式this传递，所以不能直接访问实例变量（需要对象点，因为没有this）

                解释:

                何时用：方法的操作与对象无关(不会用对象的属性)

静态块：

        static修饰

        属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次

        何时用：初始化/加载静态资源（图片，音频，视频等）

final：最终的，不可改变的-----------单独使用几率低

        修饰变量：变量不能被改变

        修饰方法：方法不能被重写

        修饰类：final的类不能被继承  但是可以继承别的类

static final 常量：应用率高

        必须声明的同时初始化

        通过类名点来访问，不能被改变

        建议，常量所以字母都大写，多个单词用_分隔

        编译器在编译时会将常量直接替换为具体的值，效率高

        何时用:数据永远不变，并且经常使用

静态变量和常量

        

抽象方法:

        由abstract修饰

        只有方法的定义，没有具体的实现

抽象类:

        由abstract修饰

        包含抽象方法的类都是抽象类

                不包含抽象方法的类也可以声明为抽象类----------了解

        抽象类不能被实例化（new 对象）

        抽象类是需要被继承的，派生类：

                *重写所有抽象方法--------------变不完整为完整

                *也声明为抽象类------------------一般不这样做   

          

抽象类的意义：

• 封装共有的属性和行为--------------------代码复用

• 为所有派生类提供统一的类型-----------向上造型---代码复用

• 可以包含抽象方法，为所有派生类提供统一的入口(能点出来)

  派生类的行为不同，但入口是一致的，同时相当于定义了一个标准

成员内部类：应用率低,了解

        类中套类, 外边的称为外部类，里面的称为内部类

        内部类通常只服务于外部类，对外部不具备可见性

        内部类对象只能在外部类中创建

        内部类中可以直接访问外部类的成员(包括私有的)，在内部类中有个隐式的引用指向了创建它的外部类对象------外部类名.this

匿名内部类：应用率高---------------------大大简化代码

        若想创建一个类（派生类）的对象，并且对象只创建一个，此时该类不必命名，称为匿名内部类

        匿名内部类中不可以修改外面的值，因为在此处该变量默认为final的

 

补充：

1.隐式对象：

        this：当前对象

        super：当前对象的超类对象

        外部类名.this：当前对象的外部类对象

2.必须记住的，API中会用的

        外部类名.this：指代当前对象的外部类对象

        匿名内部类不能修改外面变量的值，因为在此处默认为final的

 3.小面试题：

        内部类有独立的.class字节码文件吗？

        有，

4.做功能的套路：

   先写行为/方法：

           若为某对象所特有的行为，就将方法设计在特定的类中

           若为所有对象所共有的行为，就将方法设计在超类中

   窗口调用

        若为定时发生的，就在定时器中调用

        若为事件触发的，就在侦听器中调用

接口：

         

         7.接口可以继承接口（类和类 extends   接口和接口  extends    类和接口  implements）

        8.接口的意义：

                封装部分派生类共有的属性和行为，实现多继承

                是一个标准，是一种规范

       

        public static final int NUM =5;--------默认为常量 public static final

        public abstract void show();----------默认为抽象方法  public abstract 

        常量必须声明同时初始化

        抽象方法不能有方法体

        

 实现类的重写方法必须为public

接口：封装部分共有

父类：所有共有

多态：

        表现：同一个对象被造型为不同类型时，有不同的功能

                ------对象的多态：我，你，水-------------所有对象都是多态的

                同一类型的引用指向不同的对象时，有不同的实现

                -------行为的多态：cut（），move（）--所有抽象方法都是多态的

 

 向上造型可以理解为自动类型转换

强制类型转换成功的条件有两种：

        引用所指向的对象，就是该类型

        引用所指向的对象，实现了该接口或者继承了该类

不符合上面条件则发生ClassCastException类型转换异常

看指向的对象的类型与要等号左边的类型来比较，看是否可以强转

建议在强转之前先通过instanceof来判断引用对象是否是该类型

o instanceof Boo   //true

o instanceof Coo  //false

接口例子： 

补充：

    1.成员变量和局部变量是可以同名的（***同名时，访问成员变量this不可以省  this.name =name）

        成员变量：写在类中，方法外-------有默认值

        局部变量：写在方法中-----------------没有默认值

    2.java规定：成员变量和局部变量是可以同名的

                        使用的时候采取就近原则

    3.内存管理:由JVM来管理

        堆:存储new出来的对象（包括成员变量）   new出来的才放在堆    

        栈:局部变量（包括方法的参数）  ****引用类型中装的都是地址   基本类型放在栈装的值

        方法区:.class字节码文件(包括静态变量、所有方法)

        在构造方法中给实例变量做初始化

        在静态块中给静态变量做初始化

   4.数组也是一个对象，数组对象也存储在堆中，将数组的元素当作成员变量也存在堆中

声明的类型依据＝的左边

重写和重载         是否重载与返回值类型，变量名称无关

成员变量分为两种：

        实例变量：没有static修饰，属于对象的，存储在堆中

                                有几个对象就有几份，通过引用打点来访问

        静态变量：有static修饰，属于类的都存储在方法区中，

                                方法区中的都只有一份，通过类名点来访问

设计规则：abstract

        将派生类所共有的属性和行为，抽到超类中-------------抽共性        泛化

        对象的行为都一样，则设计为普通方法

        对象的行为都不一样，则设计为抽象方法
 

抽象方法/抽象类的疑问：

        抽象方法存在的意义是什么？

                *保证当发生向上造型时，通过超类的引用能点出来那个方法

          既然意义只在于能点出来，那为什么不设计为普通方法？

                *若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写----------做了个标准，强制必须重写

final与abstract意义相反

        final不能被继承

        abstract必须被继承

代码块的执行顺序：

 

静态代码块：

构造代码块：

局部代码块：