面向对象OOP

面向对象（OO）

面向对象分析（OOA）

面向对象设计(OOD）  

面向对象分析与设计（OOAD）

面向对象编程（OOP）

 

面向对象：

1.类和对象

1）定义：现实生活是有很多对象组成的，基于对象抽出了类

2）对象：真实存在的单个个体/东西

   类：代表一类个体

3）类：是对象的模板/模子，对象是累的具体实例

是一钟引用数据类型

4）类中可以包含：

（1）对象所共有的属性/数据------变量（实例变量、静态变量）

（2）对象所共有的行为/动作------方法

5）一个类可以创建多个对象

2.创建类，创建对象，访问对象

1）创建类：

2）创建对象：

 new student （）；

3）访问对象：

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

Student        zs         =     new    Student();

引用类型：

数组  类

默认值：null  

注意：

1）只要离开文件，必须先将文件保存，并保证没有错误；

2）想让程序有运行结果，一定要在main中调用action（）方法才可以

3）static的问题以后解释

1.方法的签名：方法名+参数列表

* 2.方法重载（Overload）：

1）发生在同一类中，方法名称相同，参数列表不同，方法体也不同

2）编译器在编译时会根据方法的签名自动构造方法

3）重载与返回值类型无关，重载与参数名称无关

* 3.构造方法：

1）给成员变量赋初值

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

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

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

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

5）构造方法可以重载

* 4.this：

指代当前对象，哪个对象调用方法this.就指代哪个对象

1）关键字，只能用在方法中访问成员变量之前默认有个this.

2）成员变量与局部变量同名时，若访问成员变量，则this不能省略

 （成员变量在整个类中都好使；局部变量只能在当前方法中好使）

3）用法：

（1）this.成员变量名----------访问成员变量

（2）this.方法名（）----------调用方法（一般不写）

（3）this.（）----------------调用构造方法（应用率低）

5.null和NullPointerException：

1）null：表示空，没有指向任何对象

若引用的值为null，则该引用不能在进行任何操作了

若操作则发生NullPointerException空指针异常

2）NullPointerException：空指针异常

内存管理：由JVM来管理的

1）堆：所有new出来的对象（包括成员变量）

2）栈：局部变量（包括方法参数）

3）方法区

 

1.引用类型数组：

1）

student[] stus = new student[3];

   //声明student型数组，数组有3个元素，

  //每个元素为student型，数组默认值为null



   student[] stus = new student[3];//创建student数组对象

   stus[0] = new student ("zhangsan",25,"LF");//创建student对象

   stus[1] = new student ("lisi",26,"JMC");

   stus[2] = new student ("wangwu",27,"SD");

或

 student[] stus = new student[]{

new student ("zhangsan",25,"LF"),

new student ("lisi",26,"JMC"),

new student ("wangwu",27,"SD"),

}

   Systen.out.println(stus[0].name)//输出第一个学生的姓名

   stus[1].age = 24;//将第二个学生的年龄改为24

   stus[2].sayHi();//第三个学生向大家问好



for(int i = 0;i <=stus.length;i++){

    System.out.println(stus[i].name);

}

2）Student[] stus = new Student[]{

       new Student("zs",25,"LF"),

       new Student("ls",26,"JMS"),

       new Student("ww",28,"SD")

     };

* 2.继承：

1）作用：代码复用

2）方法：通过extends来实现继承

3）超类/父类：派生类所共有的的属性和行为

   派生类/子类：派生类所特有的属性和行为

4）派生类继承超类后，派生类具有：派生类+超类的属性和行为

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

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

6）继承具有传递性

7）java规定：构造派生类之前必须先构造超类

   （1）若派生的构造方法中没有调用超类的构造方法

----则默认super（）调超类的无参构造方法

   （2）若派生类的构造方法中调用了超类的构造方法，

         ----则不再默认提供

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

1. Super

指代当前对象的超类对象

1）用法：

（1）super.成员变量名---------访问超类的成员变量

（2）super.方法名（）---------调用超类的方法

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

1.向上造型：

1）超类型的引用指向派生类的对象

animal o = new tiger（）；

引用类型        对象类型

2）能点出什么，看引用类型

o.  只能点出animal中的

* 2.方法重写（override）：

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

2）重写方法被调用时，看对象的类型

3）重写需要遵循“两同两小一大”原则：(理解）

两同：方法名相同

      参数列表相同

两小：派生类的返回值类型小于或等于超类方法的

1)void时，必须相同 2)基本类型时，必须相同 3)引用类型时，小于或等于

      派生类抛出的异常小于或等于超类方法的

一大：派生类方法的访问权限大于或等于超类方法的

* 3.重写与重载的区别：

                                                          ------------常见面试题（只回答1）（1），2）（1））

1）重写：

（1）发生在父子类中，方法名相同，参数列表相同，方法体不同

（2）遵循“运行期绑定”，看对象类型来调用方法

2）重载：

（1）发生在同一类中，方法名相同，参数列表不同，方法体不同

（2）遵循“编译期绑定”，看参数（引用）的类型来绑定方法

1.package和import：

1）package：

（1）作用：避免类名冲突

（2）类的全称：包名.类名   同包中的类不能冲突

（3）包名可以有层次结构

（4）建议：包名所有字母都小写

2）import：

同包中的类可以直接访问，不同包不能直接访问，若想若访问则

（1）.先import声明类在访问类

（2）.写全称---------不建议，太繁琐

2.访问控制修饰符：

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

1. public：

公开的，任何类都能访问

1. private：

私有的，只能本类访问

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

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

1. protected：

受保护的，本类，派生类，同包类均可访问

1. 默认的：

什么也不写，本类，同包类可以访问----java不建议默认权限

说明：

1）类的访问权限只能是public或是默认的

2）类中成员访问权限如以上4种都可以

3.final：

最终的，不可改变的-----单独应用几率小

1）修饰变量：变量不能被改变；

2）修饰方法：方法不能被重写；

3）修饰类：    类不能被继承

4.static：静态的

1）静态变量:

（1）由static修饰

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

（3）通常用类名.来访问

（4）何时用：所有对象所共享的数据（图片、音频、视频等）

成员变量：

  （1）实例变量：没有static修饰，属于对象，存储在堆中，有几个对象就有几份，通过对象名来访问

  （2）静态变量：由static修饰，属于类，存储在方法区中，只有一份，通过类名来访问

2）静态方法：

（1）由static修饰

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

（3）通常用类名.来访问

（4）静态方法中没有隐式的this传递，所以不能直接访问实例变量

（5）何时用：方法的操作和对象无关

3）静态块：

（1）由static修饰

（2）属于类，在类被加载期间自动访问

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

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

静态变量----------图片、音频、视频等数据

静态块------------图片、音频、视频等赋值

静态方法----------图片、音频、视频等做操作

1. static final常量：

1）必须声明同时初始化

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

3）建议：常量名所有字母都大写，多个单词用_分隔

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

5）何时用：数据永远不变，且经常使用时

2.抽象方法：

1）有abstract修饰

2）只有方法的定义，没有具体实现（连大括号也没有）

3.抽象类：

1）由abstract修饰

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

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

   只要是数据类型就能创建数组对象

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

（1）重写所有抽象类----变不完整为完整

（2）也声明为抽象类----一般不使用

5）抽象类的意义：

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

2）为所有派生类提供统一的类型----向上造型

3）可以包含抽象方法，为派生类提供统一接口（能点出什么）

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

1.成员内部类：

1）类中套类；外面的类称为Outer外部类，里面的类称为Inter内部类

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

3）内部类对象通常是在外部类中创建的

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

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

    语法：外部类名.this.对象

2.匿名内部类：简化代码

1）若想创建一个类（派生类）的对象，且对象只被创建一次，

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

1. 匿名内部类中若想访问外面的变量，该变量必须是final的（JDK1.7（含）以前的要求）

1.接口：

1）语法：用implements实现接口

（1）是一种数据类型（引用数据类型）

（2）由Interface定义

（3）只能包含常量和抽象方法

（4）接口不能被实例化

（5）接口是需要被实现/继承的，实现类/派生类：

必须重写所有抽象方法

（6）一个类可以实现多个接口，用逗号分隔

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

1.多态：

1）意义：

（1）行为的多态：同一个类型的引用指向不同的对象时，有不同的实现

（2）对象的多态：同一个对象被造型为不同的类型时，有不同功能

2）向上造型：

（1）超类型的引用指向派生类的对象

（2）能造型成为的数据类型：超类+做实现的接口

（3）能点出什么，看引用类型

3）强制类型转换：

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

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

4）强转时若不符合如上条件，则发生classcastexception类型转换异常

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

1.内存管理：

1）堆

（1）存储new出来的对象（包括实例变量）

（2）垃圾：没有任何引用所指向的对象

     垃圾回收器（GC）不定时到内存堆中回收垃圾

     回收过程是透明（看不到）的，不一定一看到垃圾立刻回收

     通过调用system.gc（）建议jvm尽快调度GC回收

（3）实例变量的生命周期

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

（4）内存泄漏：不再使用的内存还没有被及时回收

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

2）栈

（1）存储正在调用的方法中的局部变量（包括方法的参数）

（2）调用方法时，会在栈中为该方法分配一块对应的栈帧，

栈帧中存储局部变量（包括参数）

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

（3）局部变量的生命周期：

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

3）方法区

（1）存储在.class字节码文件（包括静态变量，方法）

 

2.面向对象三大特征：（面试题）

1）封装：

（1）类：封装的是对象的属性和行为

（2）方法：封装的是具体的业务逻辑功能实现

（3）访问控制修饰符：封装的是具体的访问权限

2）继承：

（1）作用：代码复用

（2）超类：所有派生类所共有的属性和行为

     接口：部分派生类所具有的属性和行为

     派生类：派生类所特有的属性和行为

（3）单一继承、多接口实现，具备传递性

3）多态：

（1）行为多态：所有抽象方法都是多态的

     对象多态：所有对象都是多态的

（2）向上造型、强制类型转换、instanceof判断

（3）多天的表现形式：

重写：表现行为的多态

向上造型：表现对象的多态