黑马程序员_面向对象知识点整理

最新推荐文章于 2022-10-31 10:33:29 发布

qq_16227809

最新推荐文章于 2022-10-31 10:33:29 发布

阅读量390

点赞数

分类专栏： java学习日志

本文链接：https://blog.csdn.net/qq_16227809/article/details/36058013

版权

java学习日志专栏收录该内容

12 篇文章 0 订阅

订阅专栏

------- android培训、java培训、期待与您交流！ ----------

根据java基础班的课堂教学整理的面向对象知识点，留着以后看。

1：面向对象(理解)

(1)是相对应面向过程而言的，基于面向过程的一种编程思想。

(2)思想特点：

A:更符合我们思考习惯的思想。

B:把复杂的简单化。

C:把我们从执行者变成了指挥者。(角色转换)

(3)怎么着才能让我们写的程序符合面向对象思想

a:找类

b:类有什么

c:类与类的关系

2：类与对象的关系(理解)

(1)编程语言都是为了把现实世界的事物给描述出来的。

(2)现实世界的事物体现：

特征：外在的描述

行为：内在的行为

(3)Java语言的最基本单位：类

类和事物的转换：

事物：

特征：外在的描述

行为：内在的行为

类：

成员变量

成员方法

(4)类：是一组相关的属性和行为的抽象。

(5)对象：是该类事物的具体存在的个体。也叫做实例。

3：如何写一个类和使用一个类的成员(掌握)

(1)先把要描述的事物通过特征和行为体现。

然后把该行为和特征体现为类的成员变量和成员方法。

(2)类：

成员变量：在类中方法外的变量。

成员方法：就是没有static的函数。

(3)使用一个类：

A:在一个java文件中，可以写多个类。

但是，要求文件名和带main方法的那个类名相同。

B:如何使用：

创建对象：类名变量名 = new 类名();

这个变量名其实就是一个对象。

使用成员：

成员变量：对象名.变量名;

成员方法：对象名.方法名();

4：匿名对象(理解)

(1)没有名字的对象。

(2)应用场景：

A:(掌握) 调用方法只有一次的时候。

B:可以作为实际参数传递。

5：成员变量和局部变量的区别?(掌握)

(1)在类中的位置不同

成员变量：在类中，方法外。

局部变量：在方法内或者方法的形式参数。

(2)在内存中的位置不同

成员变量：在堆内存

局部变量：在栈内存

(3)生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失。

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失。

(4)初始化值的不同

成员变量：有默认初始化值。

局部变量：没有默认初始化值。

6：封装(理解)

(1)隐藏实现细节，提供公共的访问方式。

(2)封装的体现：

private修饰成员变量。

类或者方法本身也是封装。

(3)写代码的标准做法：(掌握)

成员变量用private修饰。

提供对应的getXxx()/setXxx()方法。

7：this关键字(掌握)

(1)代表当前类的引用对象。谁调用它代码代表谁。

(2)应用场景：

解决局部变量隐藏成员变量值的问题。

8：构造方法(掌握)

(1)作用：创建对象，并对对象的数据进行初始化。

(2)特点：

A:方法名与类名相同。

B:没有返回值类型。

C:没有返回值。

(3)注意事项：

A:如果我们没有给构造方法，系统将给出一个默认的无参构造方法。

B:如果我们给出了构造方法，系统将不再给出默认构造方法。

这个时候，我们要么不使用。要么自己给。

推荐：永远手动给出无参构造方法。

(4)给成员变量赋值的方式：

A:无参构造方法+setXxx()

B:带参构造方法

9：static关键字(理解)

(1)静态的意思。可以修饰成员变量和成员方法。

注意：一般来说，静态修饰的成员变量肯定是public修饰的。

(2)静态的特点：

A:静态是随着类的加载而加载。

B:优先于对象而存在。

一般情况下类在加载的时候并没有创建对象。

C:可以通过类名调用。

普通方法：只能通过对象调用。

静态方法：可以通过对象调用，也可以通过类名调用。

推荐使用类名调用。

D:被所有对象共享的资源。

我们会根据这句话来判断是否用静态修饰某个内容。

(3)静态方法和普通方法访问成员的区别：

A:普通方法

普通成员变量

静态成员变量

普通成员方法

静态成员方法

B:静态方法

静态成员变量

静态成员方法

(4)静态的内存图。

内容在方法区的静态区。被所有对象共享的资源。

注意：静态变量也被成为类变量。

普通变量被成员实例变量。

10：代码块(理解 -- 面试题)

(1)有大括号括起来的一段代码。

(2)分类：

A:局部代码块

限定变量的生命周期。

B:构造代码块

把多个构造方法中相同的内容提取出来。

C:静态代码块

在整个系统中加载一次的资源。

注意：

a:构造代码块，每次调用构造方法都会执行。

b:静态代码块，只执行一次。

(3)面试题：

A:请说出他们的执行顺序：

构造方法，构造代码块，静态代码块。

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

B:看程序写结果。

classDemo {

static{

System.out.println("AAA");

}

{

System.out.println("BBB");

}

publicDemo() {

System.out.println("CCC");

}

publicDemo(String name) {

System.out.println("DDD");

}

测试类：

Demod = new Demo();

Demod2 = new Demo("hello");

结果：

AAA

BBB

CCC

BBB

DDD

11：Person p = new Person();怎么实现数据的初始化?(理解)

A:加载Person.class文件进内存。

B:在栈中为p变量开辟空间。

C:在堆内存为Person对象开辟空间。new Person。

D:对Person中的成员变量进行默认初始化。

E:对Person中的成员变量进行显示初始化。

F:通过构造方法对Person中的成员变量进行初始化。

(如果有构造代码块，就先执行构造代码块初始化)

G:对象构造完毕，把地址赋值给p变量。

12：如何制作API(了解)

A:写一个Java源程序。

B:加入文档注释。

C:用javadoc工具执行

格式：

javadoc-d doc -author –version ArrayTool.java

13：继承(掌握)

(1)把多个类中的相同属性或者行为给提取出来定义到一个类中。

然后，让这多个类与该类产生一个关系，这样的话，这多个类

也就具备了该类的属性和行为。这种关系叫继承。

(2)好处：

A:提高了代码的复用性。

B:让类与类之间产生了一个关系，是多态的前提。

(3)Java中的继承特点：

A:支持单继承。

B:可以多层继承。

继承体系。

(4)继承间的成员关系：

A:成员变量

a:变量名不同，这个太简单。用谁就是谁。

b:变量名相同。

子类的方法中，使用一个变量的时候：

首先，在局部范围找，如果有就使用。

否则，在成员范围找，如果有就使用。

否则，在父类成员范围找，如果有就使用。

否则，报错。

B:构造方法

a:子类初始化的时候，先初始化父类的数据。

b:任何子类的构造方法的第一行，默认是super()。

这表示调用父类的无参构造方法。

c:父类如果没有无参构造方法：

使用super(...)调用父类的带参构造

使用this(...)调用本类的其他构造。(肯定有一个去调用了父类的构造)

d:使用this(...)或者super(...)必须放在第一条语句。

这样就可以避免对父类数据多次初始化。

C:成员方法

a:方法名不同，这个太简单。用谁就是谁。

b:方法名相同。方法声明都相同。(方法重写)

用子类对象调用方法时：

首先，找子类中是否有，如果有就使用。

否则，找父类中是否有，如果有就使用。

否则，找父类的父类.....

否则，报错。

(5)方法重写的注意事项：

A:父类私有方法不能被重写。

B:子类重写父类的方法的访问权限要大于等于父类方法的访问权限。

一般，子父类一致即可。

C:静态只能重写静态。

这个不属于方法重写。多态中给验证。

(6)this和super的理解及应用场景：

this：当前类的引用对象。

super:父类的存储空间标识。可以理解为父类的引用对象。

应用场景：

A:成员变量

this.变量

super.变量

B:构造方法

this(...)

super(...)

C:成员方法

this.方法名()

super.方法名()

14：final(掌握)

(1)final是一个关键字，可以修饰类，成员方法，成员变量。

(2)特点：

A:它修饰的类不能被继承。

B:它修饰的成员变量是一个常量。

C:它修饰的成员方法不能被重写。

(3)面试题：

A:final修饰局部变量

B:final修饰形式参数

基本类型：值不能发生改变

引用类型：地址值不能发生改变，对象的内容可以改变。

C:final的初始化时机。

在对象构造完毕前赋值即可。

静态的常量在定义的时候就赋值。(也可以在静态代码块里面赋值)

15：多态(掌握)

(1)同一个对象，在不同时刻表现出来的多种状态。

举例：

A:水(水蒸气，冰，水)

B:动物 d = new Dog();

d = new Cat();

(2)多态的前提：

A:要有继承或者实现关系

B:要有方法的重写

大部分情况下，父类的方法都是抽象的，不重写没有意义。

C:要有父类引用或者父接口引用指向子类对象

(3)多态的好处：

A:提高代码复用性。其实是有继承保证的。

B:提高程序的扩展性。尽量不要使用具体的东西。

(4)多态的弊端：

不能访问子类的特有功能。

(5)多态中的成员特点：

Fuf = new Zi();

A:成员变量编译看左边，运行看左边

B:成员方法编译看左边，运行看右边

C:静态方法编译看左边，运行看左边(静态的方法其实不叫重写)

(6)在多态中的转型：

A:向上转型

从小类到大类型。

B:向下转型

从大类型到小类型。

需要做强制类型转换，并且还可能隐含转型问题。

ClassCastException

(7)多态的表现形式

A:具体类多态

B:抽象类多态

C:接口多态

16：抽象类(掌握)

(1)把多个类中的相同的方法声明进行抽取，定义到一个类中。

而一个方法如果只有声明，没有方法体，就是抽象方法。

用abstract来表示。在一个类中，如果有抽象方法，该类

一定是抽象类。

(2)抽象类的特点：

A:抽象类和抽象方法都要用abstract修饰

B:有抽象方法的类一定是抽象类

抽象类不一定有抽象方法

C:类继承抽象类的时候：

要么重写所有抽象方法

要么本身也是抽象类

D:抽象类不能被实例化。

但是它有构造方法，用于子类访问父类数据的初始化。

(3)抽象类的成员特点：

A:成员变量可以是变量，也可以是常量

B:构造方法有构造方法

C:成员方法可以是抽象的，也可以是非抽象的。

(4)抽象类的好处：

A:抽象类中的非抽象方法可以提高代码的复用性。

B:抽象类中的抽象方法强制要求子类必须做某些事情。

(5)抽象类的小问题：

A:抽象类中有没有构造方法?如果有，它不能实例化，有什么用?

B:如果一个类中没有抽象方法，而该类确被定义为了抽象类，请问为什么?

C:abstract不能和哪些关键字共存?

a:private冲突

b:final 冲突

c:static没有意义

17：接口(掌握)

(1)如果一个抽象类中的方法都是抽象的，这个时候，java就提供了一种更抽象的表现形式：接口。

(2)接口的相关小知识：

接口的表现形式：

interface接口名 {}

类怎么实现这个东西：

class类名 implements 接口名 {}

(3)接口的特点：

A:接口用关键字interface表示

B:类实现接口用关键字implements表示

C:类实现接口的时候：

要么重写接口中的所有方法

要么类本身是抽象类

D:接口不能被实例化。

(4)接口的成员特点：

A:成员变量只能是常量。默认修饰符：public static final

B:成员方法只能是抽象。默认修饰符：public abstract

推荐：自己写出修饰符。

(5)接口的思想特点：

A:接口是对外暴露的规则(USB口)

B:接口是扩展功能

C:接口降低了耦合性

耦合：类与类的关系

内聚：类本身完成某件事情的能力。

开发要求：高内聚，低耦合。

安全和效率的问题。

D:接口的出现让我们可以多实现了。

(6)接口与类之间的关系：

A:类与类的关系：

继承关系，只能单继承。但是可以多层继承。

B:类与接口的关系：

实现关系，可以单实现，也可以多实现。

还可以在继承一个类的同时，实现多个接口。

C:接口与接口的关系：

继承关系，可以单继承，也可以多继承。

(7)抽象类和接口的区别

A:成员区别

抽象类：

a:成员变量可以是变量，也可以是常量

b:构造方法有构造方法

c:成员方法可以是抽象的，也可以是非抽象的。

接口：

a:成员变量只能是常量。默认修饰符：public static final

b:成员方法只能是抽象。默认修饰符：public abstract

B:关系区别

a:类与类的关系：

继承关系，只能单继承。但是可以多层继承。

b:类与接口的关系：

实现关系，可以单实现，也可以多实现。

还可以在继承一个类的同时，实现多个接口。

c:接口与接口的关系：

继承关系，可以单继承，也可以多继承。

C:设计理念区别

类继承体现的是：is a的关系。父类中一般定义的是共性的内容。

接口被实现体现的是：like a的关系。接口中一般定义的扩展功能。

18：包(掌握)
(1)其实就是文件夹。
(2)作用：用于区分类名的，保证相同的类名可以在不同的包下。
使用的时候，用的是哪个包下的类，必须加类的全路径。
(3)定义包的格式：
package 包名.包名....;
(4)带包的类的编译和运行
A:手动式
a:编写带包的java文件
b:通过javac编译生成class文件
c:手动创建文件夹
d:把b步骤的class文件扔到c步骤的文件夹中
e:通过java命令执行，但是类一定要使用全路径。
格式: java cn.itcast.HelloWorld
B:自动式
a:编写带包的java文件
b:通过javac编译的时候，带参数编译。
格式：javac -d . HelloWorld.java
c:通过java命令执行，但是类一定要使用全路径。
格式: java cn.itcast.HelloWorld

19：导包(掌握)
(1)不同包下的类之间的访问
这个时候，如果我们对某一个类多次使用，每次都加全路径，
太麻烦，所以我们通过导包的方式解决这个问题。
(2)导包的格式：
import 包名.包名....类名;
(3)定义包，导包，定义类的顺序关系
package > import > class

常见的修饰：
类：public(一个文件就一个class)

成员变量：private(给出对应的getXxx()/setXxx())

构造方法：public(用private是为了不让外界创建对象)

成员方法：public

22：内部类(理解)
(1)把类A定义在类B的内部，类A就被成为内部类。
(2)访问特点：
A:内部类可以直接访问外部类的成员，包括私有。
B:外部类访问内部类的成员必须要创建对象。
(3)内部类的分类：
A:成员内部类
B:局部内部类
(4)成员内部类的修饰符
A:private 为了保证数据的安心性
B:static 为了访问方便
(5)局部内部类
A:局部内部类访问局部变量必须被final修饰。
原因：方法被访问后，局部变量就消失，但是这个时候对象的内容还没有立即消失。
所以，局部变量被局部内部类访问必须加final。
(6)匿名内部类：
A:是没有名字的内部类。
B:前提：
存在着一个类或者接口。
C:格式：
new 类或者接口名(){
重写类或者接口的方法。
};

理解：本质是继承了类或者实现了接口的子类匿名对象。
(7)形式参数和返回值类型
形式参数：
基本类型将来应该传递一个该类型的数值。
引用类型将来应该传递Student类的对象。
返回值类型：
基本类型返回的是该类型的一个值。
引用类型返回的是该类型的一个对象。

如果形式参数或者返回值类型是抽象类或者接口：
这个时候肯定是该抽象类或者接口的子类对象。

class Demo {
public void show(int x) {

}

public void show2(Student s) {

}

public int get() {
return 10;
}

public Student get2() {
return new Student();
}
}

(8)案例：
A:开发中的用法
interface Inter {
public abstract void show();
}

class InterImpl implements Inter {
public void show() {
System.out.println("show");
}
}

class InterDemo {
public void method(Inter i) {
i.show();
}
}

class InterTest {
public static void main(String[] args) {
//需求：我要调用InterDemo类的method()方法。
InterDemo id = new InterDemo();
Inter i = new InterImpl();
id.method(i);

id.method(new Inter(){
public void show(){
System.out.println("show");
}
});
}
}
B:面试题
interface Inter {
void show();
}

class Outer {
public static Inter method() {
return new Inter(){
public void show(){
System.out.println("HelloWorld");
}
};
}
}

class Test {
public static void main(String[] args) {
Outer.method().show();
}
}