面向对象知识点总结

1：面向对象：

通过创建某一个类的对象，而去调用类中的变量和方法，得到事物的属性和行为达到目的

oop:面向对象编程

ooA:面向对象分析

OOD:面向对象设计

 

 

2：什么是类，什么是对象：

基于对象抽出了类  类是对象的模板，对象是类的具体的实例

对象:真实存在的单个的个体

类:类型、类别，代表一类个体，定义了一种抽象数据类型

类中可以包含:

所有对象所共有的特征/属性------变量

所有对象所共有的行为-----------方法

成员变量-----有几个对象就有几份

方法---------只有一份

补2.1null 和NullPointerException

引用类型变量没有指向任何对象，为null,而访问了对象的成员变量或调用了方法

2.2构造方法:

  1)常常给成员变量赋初值

  2)与类同名，没有返回值类型

  3)在创建(new)对象时被自动调用

  4)若自己不写构造方法，则编译器默认一个无参构造方法，

    若自己写了构造方法，则编译器不再默认提供

  5)构造方法可以重载

this:指代当前对象，哪个对象调指的就是哪个对象

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

  this的用法:

    1)this.成员变量名------访问成员变量

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

       3)this()---------------调用构造方法

3：内存管理：

基本数据类型装数

引用类型装地址，默认值为null

 

       1)堆:

    1.1)存储所有new出来的对象(包含成员变量)

       1.2)没有任何引用所指向的对象就是垃圾，GC是JVM自带的一个线程(自动运行着的程序)，用于回收垃圾

           垃圾回收器(GC)不定时清理垃圾，回收过程是透明的(看不到的)，调用System.gc()建议GC尽快来回收

       1.3)成员变量的生命周期:

            创建对象时存在堆中，对象被回收时一并被回收

       1.4)内存泄露:不再使用的对象没有被及时的回收

          建议:对象不再使用时及时将引用设置为null

  2)栈:

    2.1)用于存储正在调用中方法的所有局部变量(包括参数，mian中的变量也为局部变量)

       2.2)调用方法时在栈中为该方法分配一块对应的栈帧，

           栈帧中存储的是方法中的所有局部变量(包括参数)，

              方法调用结束时，栈帧被清除，局部变量一并被清除

       2.3)局部变量的生命周期:

            调方法时存在栈中，方法结束时与栈帧一起被清除

  3)方法区:

    3.1)用于存储.class字节码文件(包括方法)

       3.2)方法只有一份，通过this来区分具体的对象

4：成员变量与局部变量的区别

局部变量：

定义在方法中；

没有默认值，必须自行设定初始值

方法被调用时，存在栈中，方法调用结束，从栈中清除

成员变量：

定义在类中，方法外

有默认初始值，可以不显示初始化

所有类被实例化后，存在堆中，对象被收回时，成员变量失效

成员变量的分类：

1)实例变量:没有static修饰

           属于对象的，存储在堆中，

                 有几个对象就有几份

                 通过对象点来访问

2)静态变量:有static修饰

           属于类的，存储在方法区中，

                 只有一份

                 通过类名点来访问

5：继承

2.1)作用:实现代码的复用，避免代码的重复

  2.2)通过extends来实现继承

  2.3)父类:所有子类所共有的属性和行为

      子类:子类所特有的属性和行为

2.7)java规定，构造子类之前必须先构造父类

      若子类构造中不调用父类的构造，则默认super()调用父类的无参构造

class A {

               privateint a = 100;

               A(){ System.out.print("A()");

               System.out.println(a);} }

              

               classB extends A {

               privateint a = 200;

               B(){ System.out.print("B()");

               System.out.println(a);} }

               运行下面的代码： new B(); 输出的结果是：（）。

       A:A() 100 B() 200  B. A() 200 B()200

       C.B() 200 A() 100   D.B() 200 A() 200

正确答案：A

          若子类构造中调了父类的构造，则不再默认提供

子类构造器执行的第一行代码使用this显式调用本类中重载的构造器，系统将根据this调用里传入的实参列表调用本类中的另一个构造器。执行本类中另一个构造器时即会调用父类构造器。

          super()调用父类的构造必须位于子类构造的第一句

6:重写与重载的区别

1)重写(Override):

    1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同，返回值父类大于或等于子类

       1.2)遵循"运行期"绑定，根据对象的类型来调用方法

  2)重载(Overload):

    2.1)发生在同一类中，方法名称相同，参数列表不同，方法体不同,与返回值类型无关

       2.2)遵循"编译期"绑定，根据引用(参数)的类型来绑定方法

调用时： 重载看引用  重写看对象

 

 

子类可以重写(覆盖)父类的方法。方法的重写要遵循“两同两小一大”规则，

“两同”即方法名相同，形参列表相同；

“两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，

子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；

“一大”指的是子类方法的访问权限应比父类方法的访问范围更大或相等。

 在Java语言中，允许多个方法的名称相同，但参数列表不同，称之为方法的重载。

7：访问控制修饰符

1)public:公开的，任何类

  2)private:私有的，本类

  3)protected:受保护的，本类、子类、同包类

  4)默认的:什么也不写，本类、同包类

  类的访问修饰符有:public和默认的

  类中成员的访问修饰符有:如上4种都可以

8：static修饰 静态的

与对象无关-------适合静态

与对象有关-------不适合静态

1)静态变量:

    1.1)由static修饰

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

       1.3)常常通过类名点来访问

       1.4)何时用:所有对象所共享的数据(图片、音频、视频等)

  2)静态方法:

    2.1)由static修饰

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

       2.3)常常通过类名点来访问

       2.4)静态方法没有隐式的this传递，

          静态方法中不能直接访问实例成员(类中的非静态成员变量方法)

       2.5)何时用:方法的操作仅与参数相关而与对象无关

 2.6）静态方法不能被重写

  3)静态块:

    3.1)由static修饰

       3.2)属于类的，在类被加载期间自动执行，

          类只被加载一次，所以静态块也只执行一次

       3.3)何时用:常常用于初始化静态资源(图片、音频、视频等)

4）静态类

 4.1）static只能修饰内部类 修饰内部类时，可直接通过对象点外部类点调用其方法

9：final修饰 最终的

1)修饰变量:变量不可被改变

  2)修饰方法:方法不可被重写

  3)修饰类:  类不可被继承

4）final与abstract不能共存

10：staticfinal修饰常量

  1)必须声明同时初始化

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

  3)建议:常量名所有字母都大写(多个单词间用_)

  4)在编译时被自动替换为具体的值，效率高

11：抽象方法

       1)由abstract修饰

   2)只有方法的定义，没有方法具体的实现(大括号都没有)

12：抽象类

       1)由abstract修饰

  2)包含抽象方法的类必须是抽象类

    不包含抽象方法的类也可以声明为抽象类----我乐意

  3)抽象类不能被实例化(创建对象)

  4)抽象类是需要被继承的，子类:

    4.1)重写所有抽象方法---建议

       4.2)也声明为抽象类-----不常这样做

  5)抽象类的意义:

   5.1)封装子类所共有的属性和行为-------继承父类

       5.2)为所有子类提供了一种统一的类型---向上造型

       5.3)可以包含抽象方法，为所有子类提供了统一的入口

           子类的具体实现不同，但入口的定义是一致的

13：接口

(当一种类型，既有….也有….用接口  或部分共有用接口)

       接口是一种特殊的抽象类，即只包含有抽象方法的抽象类

1)是一种标准、规范(制定方)

    遵守了这个标准就能干某件事---------API后

  2)是一种数据类型(引用类型)

  3)由interface定义，只能包含常量和抽象方法

  4)接口不能被实例化

  5)接口是需要被实现(implements)的，实现类:

      必须重写接口中的所有抽象方法

  6)一个类可以实现多个接口，

    若又继承又实现时，应先继承后实现

  7)接口可以多继承接口

14：接口与抽象类的区别

1）       单继承多实现

2）       关键字不同

3）       抽象类可以有非抽象方法，接口都是抽象方法

4）       接口只能定义常量抽象类可以有变量

15：多态

 行为的多态   对象的多态

       1)意义:

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

           行为的多态:cut()、run()、study()

       1.2)同一个对象被造型为不同的类型时，有不同的功能

           对象的多态:我、你、水

   2)向上造型:

    2.1)父类型的引用指向子类的对象

        2.2)能造型成为的类型:父类、所实现的接口

        2.3)能点出来什么，看引用的类型

   3)强制类型转换，成功的条件只有两种:

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

         3.2)引用所指向的对象，实现了该接口

    4)若不符合如上两个条件，则ClassCastException类型转换异常

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

Aoo o1=new Boo();//向上造型

      Booo2=(Boo)o1;//o1指向的对象就是Boo类

      Inter1o3=(Inter1)o1;//o1指向的对象实现了Inter1接口

//Coo o4=(Coo)o1;//语法没错，运行报ClassCastException异常

      if(o1instanceof Coo){

         Cooo5=(Coo)o1;

      }           

      System.out.println("over")

   }

}

interface Inter1{}

 classAoo{ }

 class Booextends Aoo implements Inter1{ }

 class Cooextends Aoo{}

 

5）      表现形式

   重写  重载

16：成员内部类

(内部类有独立的.class文件)

1)类中套类，外面的称为外部类，里面的称为内部类

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

  3)内部类通常在外部类中创建

  4)内部类中可以直接访问外部类的成员(包括私有的)

    内部类中有个隐式的引用指向了创建它的外部类对象

          外部类名.this

17:匿名内部类

       1)若想创建一个类(子类)的对象，并且该对象只被创建一次，

    此时该类不必命名，称之为匿名内部类

  2)匿名内部类中访问外面的数据，该数据必须是final的

new TimerTask(){},//TimerTask匿名内部类

MouseAdapter l=newMouseAdapter(){//MouseAdapter的匿名内部};

18：面向对象三大特征

1)封装:

    1.1)类:封装的是对象的属性和行为

       1.2)方法:封装的是具体的业务逻辑功能实现

       1.3)访问控制修饰符:封装的是访问的权限

  2)继承:

    2.1)作用:代码的复用

       2.2)通过extends来继承

       2.3)子继承父后，具有:父+子

       2.4)单一继承、传递性

       2.5)继承类、实现接口

  3)多态:

    3.1)意义:行为的多态、对象的多态

       3.2)向上造型、强制类型转换、instanceof

       3.3)表现形式:

          3.3.1)重写

              3.3.2)重载

19：类class  类库classlibrary  包package jar文件  的关系

Class 是对某种类型的对象定义变量和方法的原型  表示对一类具体的共同特征的事物的抽象

Package是类的容器，用于分隔类名空间

Class library 用来实现各种功能的类的集合

Jar文件用于发布和使用类库  可被编译器和jvm直接使用

 

20：设计思路

1）      找对象

2）      抽类

3）      设计类的成员变量和方法

4）      创建对象并测试

21：面向对象的设计思想:

1)对象、类:

  1.1)数据的封装--成员变量

  1.2)方法(操作数据)的封装

2)构造方法:给数据(成员变量)赋初值

  实例方法:操作对象的数据---与对象有关

  静态方法:操作参数的数据---与对象无关 直接类点调用

  抽象方法:方法体没法写-----只能父类/接口中

3.继承:

  1)作用:代码复用

  2)很多类中有重复的代码时，设计父类来继承

    2.1)普通父类:没有抽象方法时

       2.2)抽象类:有抽象方法时

       2.3)接口:完全抽象方法时

4.设计规则:

  1)将公共的属性和行为，抽象到父类中

  2)所有子类方法的实现都一样-----普通方法

    所有子类方法的实现都不一样---抽象方法

  3)所有子类共有的，抽到父类中

    部分子类共有的，抽到接口中

       符合既是也是时，使用接口

       接口是对继承的单根性的扩展