面相对象笔记

来源：互联网发布：身份证复制知乎编辑：程序博客网时间：2024/05/05 03:34

面向对象
1.面相对象思想的特点：
a ：是符合我们思想习惯的思想
b ：可以将复杂的事情简单化
c ：将我们从执行者变成指挥者（角色发生了转换）
2.面向对象开发
a ：就是不断地创建对象，使用对象和维护对象的关系
3. 面向对象的特征
封装（encapsulation）
继承（inheritance）
多态（polymorphism）
4.我们学习编程是为什么
为了把我们日常生活中实物用学习语言描述出来
5.我们如何描述现实世界的事物
属性就是该事物的描述信息（事物身上的名词）
行为就是该事物能够做什么（事物生身上的动词）
6.Java中最基本的单位是类，Java中的class描述事物也是如此
成员变量就是事物的属性
成员方法就是事物的行为
7.定义类其实就是定义类的成员（成员变量和成员方法）
成员变量和以前定义变量是一样的，只不过位置发生了改变，在类中方法外。
成员方法和以前定义方法是一样的，只不过把static去掉，后面会讲到
8.类和对象的概念
类就是一组相关属性和行为的集合
对象就是该类事物的具体体现
9.创建对象
创建对象的格式：类名对象名 = new 类名();
对象名：其实就是合法的标识符，如果是一个单词所有的字母都小写，如果是多个单词，从第二个单词开始所有的首字母都大写
10.如何使用成员变量和成员方法
对象名.变量名;
对象名.方法名(……);
11.一个对象的内存图
Java在内存中会把内存分为三个区：栈，堆，方法区
方法区：编译后的Java文件变成class文件，在运行时字节码文件从硬盘上加载到内存，这时加载到的地方就是方法区，存在主方法所在的类最先加载到方法区，每次用到一个类就会先把这个类加载到方法区
栈：每当调用方法的时候该方法就会被压进栈，栈是先进后出，每用完一个方法这个方法将会弹出栈
堆：是创建的对象所在的地方，也就是每new一次就会在堆里创建一个对象

12.俩个对象的内存图
如果没有任何引用指向改对象，那么该对象就会变成垃圾，Java中有完善的垃圾回收机制，会不定时的进行垃圾回收。

13.三个引用两个对象的内存图

14.成员变量和局部变量的区别
a ：在类中的位置不同
成员变量在类中方法外
局部变量在方法定义中或者方法声明上
b ：在内存的位置不同
成员变量在堆内存中（成员变量属于对象，对象在堆内存中）
局部变量在栈内存中（局部变量属于方法，方法在栈内存中）
c ：生命周期不同
成员变量随着对象的创建而存在，随着对象的消失而消失
局部变量随着方法的调用而存在，随着方法的调用完毕而消失
d ：初始化值不同
成员变量有默认初始化值
局部变量没有默认初始化值，必须定义，赋值然后才能使用（如果定义时没赋值，那么在使用之前一定要赋值）
注意事项
a ：局部变量名称可以和成员变量名称一样，在方法的使用的时候采用的是就近原则
b ：基本数据类型变量包括哪些？byte short int long float double Boolean char
c ：引用数据类型包括哪些? 类数组接口枚举
15.匿名对象
什么是匿名对象？
匿名对象就是没有名字的对象
New 类的名字().方法名(…..);
匿名对象应用的场景
a ：调用方法，仅仅调用一次的时候
那么，这种匿名调用有什么好处？
节省代码
注意：调用多次的时候，不适合。每用一次就会在堆里产生一个对象，匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
匿名对象是否可以调用属性并赋值？有什么意义？
匿名对象可以调用属性，但是没有意义，因为调用后就变成垃圾了，如果赋值还是用有名字的对象好

b ：匿名对象可以作为实际参数传递
16.类的封装
A:封装的概念：封装就是隐藏对象的属性和实现细节，仅对外提供公共的访问方式
B:封装的好处：隐藏实现细节，提供公共的访问方式。
提高了代码的复用性
提高了安全性
C:封装的原则: 将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共的方法对其访问
Private关键字的特点：是一个权限修饰符
可以修饰成员变量和成员方法
被其修饰的成员只能在本类中访问
Private仅仅是封装的一种体现形式，不能说封装就是私有
This关键字代表当前对象的引用，谁来调用我，我就代表谁。This调用的一定是成员变量。
This关键字应用的场景：当成员变量和局部变量重名的时候
Getxx方法里的return后面的this.xx; 中的this可以省略，系统默认会给你加上
17.构造方法
构造方法的概述和作用：给对象的数据（属性）进行初始化。
构造方法的格式特点：方法名与类名相同（大小写也相同与类名一致）
没有返回值类型，连void都没有
没有具体的返回值有return；后面没有返回值（return用于方法中的两种作用一种是返回值一种是结束方法。由于构造方法没有返回值所有return 在构造方法中只能结束方法）

注意：在一创建对象的时候，系统就自动调用构造方法了，构造方法不能用对象调用。
18.构造方法的重载
重载：方法名相同，与返回值无关（构造方法没有返回值），只看参数列表
构造方法的注意的事项：如果我们没有给出构造方法，系统将自动提供一个无参数的构造方法。
如果我们给出构造方法，系统将不再提供默认无参数构造方法。这个时候如果我们还想使用无参数的构造方法，就必须自己给出。建议永远自己给出无参数构造方法

构造方法和setxx的区别：构造方法主要是用来初始化，getxx方法主要是修改属性，在开发中setxx用的比较多，因为他用起来比较灵活

19.创建一个对象的步骤
以创建一个学生对象为例：Student s = new Student();
1. Student.class加载进内存
2. 声明一个Student类型的引用
3. 在堆内存中创建对象
4. 给对象中属性默认初始化值
5. 属性进行显示初始化值
6. 构造方法进栈，对对象中的属性赋值，构造方法弹栈
7. 将对象的地址值赋值给s

20.static关键字及内存图

Static关键字的特点：
1. 随着类的加载而加载
2. 优先于对象的存在
3. 被类的所有对象共享
4. 可以通过类的名字进行调用
a) 其实也可以通过对象名调用
b) 推荐使用类名调用
c) 静态修饰的内容一般我们称其为：与类相关的类成员

Static关键字的注意事项
1. 在静态方法中是没有this关键字的
a) 如何理解呢？
 静态是随着类的加载而加载，this是随着对象的创建而存在的
 静态比对象优先存在
2. 静态方法只能访问静态的成员变量和静态的成员方法
a) 静态方法：
 成员变量：只能访问静态变量
 成员方法只能访问静态的成员方法
b) 非静态方法
 成员变量：可以是静态的，也可以是非静态的
 成员方法：可以是静态的，也可以是非静态的成员方法
c) 简单记：静态只能访问静态，非静态可以访问一切。但如果在一个类中想要用静态方法去访问非静态，那么一定要在这个方法中先生成这个类的一个对象，然后用这个对象去调用方法外的非静态。

静态变量和成员变量的区别：
1. 所属不同
a) 静态变量属于类变量，所以也称为类变量
b) 成员变量属于对象，所以也称为实例变量（对象变量）
2. 内存中的位置不同
a) 静态变量储存于方法区的静态区
b) 成员变量存储于堆内存
3. 内存出现的时间不同
a) 静态变量随着类的加载而加载，随着类的消失而消失
b) 成员变量随着对象的创建而存在，随着对象的消失而消失
4. 调用方法不同
a) 静态变量可以通过类名调用，也可以通过对象调用
b) 成员变量只能通过对象调用
补充：如果一个类中所有的方法都是静态方法，那么就把他的构造方法设置成私有的，目的是不让其他类创建本类的对象，直接用类名调用即可。
21.main方法的格式详解（了解）
public static void main(String[] args)其中：
public: 被JVM调用，访问权限要足够大
static：被JVM调用，不用创建对象，直接用类名访问
void：被JVM调用，不需要给JVM返回值
main: 一个通用的名称，虽然不是关键字，但是被JVM识别
String[] args 以前用于接受键盘录入的。其中args是数组名，可以修改。
22.关于API，学了俩个API：
1. Scanner :关于键盘输入的一个类，
a) 其中一个构造方法：new Scanner(System.in);
b) 输入一个整数的方法nextInt();
2. Math ：一个关于数学运算的一个类，它里面的所有的方法都是静态的方法，直接通过类名调用，所以他的构造方法全部都私有化，API文档中不显示。
a) 一个求随机数的方法：random(); 会随机生成一个从0.0到1.0之间的一个数。
23.代码块
1. 局部代码块：
a) 在方法中出现，限定变量生命周期，及早释放，提高内存利用率。
2. 构造代码块（初始化代码块）：
a) 在类中方法外出现，多个构造方法方法中相同的代码存到一起（提高了代码的复用性），每次调用构造方法都会执行一次（也就是每创建一次对象），并且是在构造方法前执行。
3. 静态代码块：
a) 在类中方法外出现，加上static修饰。
b) 在类中方法外出现，并加上static修饰，用于给类进行初始化，在类加载的时候就执行，并且只执行一次。
c) 一般由于加载驱动。
24.继承
1. 作用：用extens让类和类之间产生关系，子父类关系。
2. 继承的好处：
a) 提高了代码的复用性
b) 提高了代码的维护性
c) 让类和类之间产生了关系，是多态的前提
3. 继承的弊端：
a) 类的耦合性增强了
b) 开发的原则：高内聚，低耦合（耦合是类和类的关系，内聚是自己完成某件事的能力）
4. Java中继承的特点：
a) Java中只支持单继承，不支持多继承（一个儿子只有一个亲爹），
（有些语言是支持多继承的）
b) Java支持多层继承（继承体系）
c) 如果想用这个体系的所有功能用最底层的类创建对象
d) 如果想看这个体系的共性功能，看最顶层的类
5. 继承的注意事项：
a) 子类只能继承父类所有非私有的成员（成员方法和成员变量）
b) 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法
c) 不要为了部分功能而去继承
6. 什么时候使用继承
a) 继承其实是体系一种关系：is a（谁是谁的一种的时候）
7. 子父类成员变量的关系：
a) 子类和父类有同名变量：按照就近原则，子类有就不用父类的啦。但这种情况只是在讲课中举例子使用，在开发中是不会出现这种情况的，子类继承父类就是为了使用父类的成员，如果定义了同名成员就没有意义了.（即使父类成员变量被私有，但是父会提供get和set方法让我们去调用的）
8. this和super的区别：
a) this代表当前对象的引用，谁来调用我，我就代表谁
b) super：代表当前对象的父类引用
c) 调用成员变量的区别：
 This.成员变量调用本类的成员变量。（也可调用父类的成员变量，当子类没有该变量从父类中继承下来时）
 Super.成员变量调用的是父类的成员变量。
d) 调用构造方法的区别：
 This（…）调用的本类的构造方法
 Super（…）调用父类的构造方法
e) 调用成员方法的区别：
 This.成员变量调用本类的成员方法，（也可以调用父类的方法，当子类没有，父类的方法被继承下来的时候）
 Super.成员变量调用父类的成员方法

继承中构造方法的关系
a) 子类中的所有构造方法默认都会访问父类中的空参的构造方法。因为子类会继承父类中的数据，可能还会使用父类的数据，所以子类初始化之前，一定要先完成父类数据的初始化。
b) 其实每一个构造方法的第一条语句默认都是：super（）;访问的是Object类的构造方法，Object是所有类的父类。
继承中构造方法的注意事项：
a) 当父类没有无参数的构造方法时，要用super或this解决，但在构造方法中super和this只能用一个。因为在构造方法中super和this都必须放在第一条语句，所以在构造方法中super和this只能用一个，所以构造方法中用过this后系统默认加的super（）方法就不会再被默认加上了。
继承中子父类中的成员方法关系
a) 子类的方法和父类的方法相同时：子类会覆盖掉（重写）父类中重名的方法。如果非要调用父类中的同名方法，就用super.方法名调用。
b) 子类的方法和父类的不相同，那么子类会自动继承下来。
方法的重写
a) 概念：子父类出现了一模一样的方法（注意：返回值类型可以是子父类）
b) 应用：当子类需要父类的功能，而功能主题子类有自己的特有的内容时，子类可以重写父类中的方法，这样既沿袭了父类的功能，又有自己特定的内容
c) 注意事项：
 父类中私有方法不能被重写，因为父类私有方法子类根本就无法继承
 子类重写父类的方法时，访问权限不能更低，最好一致。
 父类的静态方法，子类也必须通过静态方法进行重写，其实这也算不上重写，但是现象确实如此，多态会学（静态只能覆盖静态）
 子类重写父类方法时，最好声明一模一样。
方法重写和重载
a) 方法重写：子类中出现了和父类中方法声明一模一样，与返回值类型有关，返回值是一致（或是子父类的关系）
b) 方法重载：本类中出现的方法名一样，参数列表不同的方法，与返回值类型无关。
final关键字
a) 修饰类：类不能被继承
b) 修饰变量：变量就变成了常量，只能被赋值一次
 一般会与public和static一起用
 修饰成员变量：修饰基本数据类型的变量，值不能变；修饰引用类型的变量，其所指向的地址值不能变，但其所指对象中的属性是可以改变的
c) 修饰方法：该方法不能被重写
d) final修饰变量的初始化时机：
 显示初始化（成员变量的默认初始化是无效的）
 在对象构造完毕前即可
25.多态（polymorphic）
概念：事物存在的多种形态
多态的前提：
 要有继承关系
 要有方法重写
 要有父类引用指向子类对象
特点：只有非静态的成员方法，编译看父类，运行看子类，其他的都是编译看父类，运行看父类
 成员变量：编译看父类，运行看父类

 成员方法：编译看父类，运行看子类（动态绑定）

 静态方法：编译看父类，运行看父类（静态和类相关，算不上重写，所以还是看父类）

向上向下转型
 向上转型：父类引用指向子类对象
 向下转型：先有向上转型，才能有向下转型
多态的好处与弊端
a) 好处：
 提高了代码的维护性（继承保证）
 调高代码的扩展性，可以当做形式参数，可以接受任意子类对象
b) 弊端：
 不能使用子类的特有属性和方法
Instanceof关键字用来判断前边的引用是否是后边的数据类型
26.抽象类
抽象类的特点
a) 抽象类和抽象方法必须用abstract关键字修饰
b) 抽象类不一定有抽象方法，有抽象方法的类一定是是抽象类或者是接口
c) 抽象类不能实例化那么，抽象类如何实例化呢？
 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象多态。
d) 抽象类的子类
 要么是抽象类
 要么重写抽象类中的所有抽象方法
抽象类的成员特点
a) 成员变量：既可以是变量，也还可以是常量。abstract是否可以修饰成员变量？不能修饰成员变量。
b) 构造方法：有。用于子类访问父类数据的初始化。
c) 成员方法：既可以是抽象的，也可以是非抽象的
抽象类的成员方法的特性
a) 抽象方法强制要求子类做的事情
b) 非抽象方法子类继承的事情，提高代码的复用性
面试题
a) 一个抽象类可以没有抽象方法，这样做的目的就是为了不让其他类创建本类的对象，交给子类完成
b) abstract不能和哪些关键字共存
 abstract不能和static共存，因为用static修饰的方法可以用类名调用，这样调用一个抽象方法没有意义
 abstract不能和final共存，abstract是为类让子类重写，final为了不让重写，这两个矛盾。
 abstarct不能和private共存，被abstract修饰的是为了让子类看到并强制重写，而被private修饰的是为了不让子类访问，这两个矛盾。
27.接口（interface）
a) 概念：从广义上的角度讲对外提供规则都是接口（接口所有的都是public类型的，接口是对外暴露的）
b) 接口的特点：
 接口用interface关键字表示
 类实现接口用implements表示
 接口不能被实例化（按照多态的方式来实例化）
 接口的子类（可以是抽象类，但是意义不大，但常用的是用具体类来重写接口中的所用的抽象方法）
 接口在编译后生成的也是class文件（字节码文件）
c) 接口成员的特点：只能是常量，并且是静态公共的
 默认修饰符：public static final（建议手动给出，并且这三个没有顺序）
 构造方法：接口中没有构造方法。
 成员方法；只能是抽象的方法，默认修饰符是public abstract（建议手动给出）
d) 类与类，类与接口，接口与接口的关系
 类与类：继承关系，只能是单继承，可以是多层继承
 类与接口：是实现关系，可以是单实现也可以是多实现，并且也可以继承成一个类的同时实现多个接口
 接口与接口：继承关系，可以是单继承，也可以是多继承
e) 抽象类和接口的区别
 成员区别：
 抽象类：
 成员变量；可以是变量，也可以是常量。
 构造方法：有
 成员方法：可以是抽象，也可以是非抽象
 接口：
 成员变量：只能是常量。
 构造方法：无
 成员方法：只能是抽象
 设计理念区别
 抽象类被继承体现的是 is a 的关系。抽象类中定义的是该继承体系的共性功能
 接口被实现体现的是 like a 的关系，接口中定义的是该继承体系的扩展功能
28．包（关键字package）
为什么要用包？
 将字节码文件（.class）进行分类存放
 包其实就是文件夹
怎样划分包
 按功能划分
 按模块划分
定义包的格式
 package 包名；
 多级包用.分开即可
包定义注意的事项
 package语句必须是程序的第一条可执行的代码
 package语句在一个java文件中只能有一个
 如果没有package，默认表示无名包
带包的类的编译和运行
 编译带包的类：javac -d . Java文件
 运行：java 包名.class文件名
import关键字
 导包其实就是让有包的类对调用者可见，不用写全类名了
 导入格式：import 包名；
 注意事项：导入包要到类的名称，虽然最后可以写*（通配符）但是不建议（因为需要查找，速度慢）
 package import class 有先后顺序，package要放在最前面，import放中间，class在他俩后面
四种权限修饰符
本类同一个包下（子类和无关类）不同包下（子类可访问）不同包下（无关类）
private Y
默认 Y Y
protected Y Y Y
public Y Y Y Y
类以及其组成所使用的常见修饰符
a) 修饰符
 权限修饰符：private 默认 protected public
 状态修饰符：static final
 抽象修饰符：abstract
b) 类
 权限修饰符：默认修饰符 public
 状态修饰符：final
 抽象修饰符：abstract
c) 成员变量：
 权限修饰符：private 默认的 protected public
 状态修饰符：static final
 抽象修饰符：abstract
d) 除此之外的组合规则：
 成员变量：pubic static final
 成员方法：public static
public abstract
public final
29.内部类（内部类调用外部类的成员变量，要得到外部类的引用(外部类名.this)）
a) 概念：在类中定义的类
b) 成员内部类的访问特点：
 内部类可以直接访问外部类的成员，包括私有
 外部类要访问内部类的成员，必须创建对象
 外部类名.内部类名对象名 = 外部类对象.内部类对象
 人如果成员内部类被私有了，要用这个外部类提供的公共方法访问调用。
c) 静态内部类
 在成员内部类加个static就是了
 外部类名.内部类对象名 = 外部类名.内部类对象（new 外部类名.内部类名（），也就是把new提前）
d) 局部内部类
 概念：在方法内定义的类
 特点：局部内部类只能在其所在的方法中使用
 局部内部类在访问其方法中的局部变量时，该变量必须用final修饰，因为当调用这个方法时，局部变量如果没有用final修饰，他的生命周期和方法的生命周期是一样的，当方法弹栈时这个局部变量也会消失，那么如果局部内部类对象还没有马上消失想用这个变量，这时就没有了，如果用final修饰的话，他会在类加载的时候进入常量池，即使这个方法弹栈，常量池的常量还在，也可以继续使用。但JDK1.8取消了这限制，我认为这是一个bug。

e) 匿名内部类（是一种局部内部类）
 就是局部内部类的简化写法
 前提这个类必须继承或实现了某个类（也可以是抽象类）或接口
 格式：new 类名或接口名(){重写方法;}
 本质：是一个继承了该类或实现了该接口的子类匿名对象
 匿名内部类只针对重写一个方法的时候使用
 匿名内部类不能向下类型转换，因为没有类名
 匿名内部类生成的class文件的名为：外部类$数字

0 0