java基础--面向对象

一、面向对象简介

(1)特点：是基于面向过程的编程思想
(2)格式：类名 对象名 = new 类名();
(3)java程序的开发，设计和特征总结

A、开发，就是不断的创建对象，通过对象调用功能

B、设计，就是管理和维护对象间的关系

C、特征，就是封装，继承，多态

二、详细掌握知识点总结

1、成员变量和局部变量的区别

A、在类中的位置不同

成员变量：类中方法外

局部变量：方法定义中或者方法声明上

B、在内存中的位置不同

成员变量：在堆中

局部变量：在栈中

C、生命周期不同

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

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

D、初始化值不同

成员变量：有默认值

局部变量：没有默认值，必须定义，赋值，然后才能使用

2、封装好处

A:隐藏实现细节，提供公共的访问方式

B:提高代码的复用性

C:提高代码的安全性

3、private关键字

被private修饰的后的成员只能在本类中被访问

4、this关键字

代表当前类的引用对象

5、构造方法

格式：

A:方法名和类名相同

B:没有返回值类型，连void都不能有

C:没有返回值

6、static关键字

静态的特点：

A:随着类的加载而加载

B:优先与对象存在

C:被类的所有对象共享

这其实也是我们判断该不该使用静态的依据。

举例：饮水机和水杯的问题思考

D:可以通过类名调用

既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。

7、代码块(理解)

(1)用{}括起来的代码。

(2)分类：

A:局部代码块

用于限定变量的生命周期，及早释放，提高内存利用率。

B:构造代码块

把多个构造方法中相同的代码可以放到这里，每个构造方法执行前，首先执行构造代码块。

C:静态代码块

对类的数据进行初始化，仅仅只执行一次。

(3)静态代码块,构造代码块,构造方法的顺序问题?

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

8、继承

(1)格式： class 子类名 extends 父类名 {}

(2)继承的好处：

A:提高了代码的复用性

B:提高了代码的维护性

C:让类与类产生了一个关系，是多态的前提

(3)继承特点：

A:Java中类只支持单继承

B:Java中可以多层(重)继承(继承体系)

(4)注意事项：

A:子类不能继承父类的私有成员

B:子类不能继承父类的构造方法，但是可以通过super去访问

C:子类的构造方法默认会去访问父类的无参构造方法,是为了子类访问父类数据的初始化

D:父类中如果没有无参构造方法,子类须通过super去明确调用父类带参构造

E:子类的构造方法默认会去访问父类的无参构造方法,是为了子类访问父类数据的初始化

(5)Override 和Overload的区别

A、Override (重写，覆盖)

1、方法名、参数、返回值相同

2、子类方法不能缩小父类方法的访问权限

3、子类方法不能抛出比父类方法更多的异常（但子类方法可以不抛出异常）

4、存在于父类和子类之间

5、方法被定义为final不能被重写

B、Overload(重载，过载)

1、参数的类型、个数、顺序至少有一个不相同

2、不能重载只有返回值不同，其他相同的方法名，

3、存在于父类和子类、同类中

9、final关键字

(1)是最终的意思，可以修饰类，方法，变量。

(2)特点：

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

B:它修饰的方法，不能被重写。

C:它修饰的变量，是一个常量。

(3)面试相关：

A:局部变量

a:基本类型 值不能发生改变

b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的

B:初始化时机

a:只能初始化一次。

b:常见的给值：定义的时候；(推荐)构造方法中。

10、多态(掌握)

(1)同一个对象在不同时刻体现出来的不同状态。

(2)多态的前提：

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

B:有方法重写。

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

多态的分类：

a:具体类多态

class Fu {}

class Zi extends Fu {}

Fu f = new Zi();

b:抽象类多态

abstract class Fu {}

class Zi extends Fu {}

Fu f = new Zi();

c:接口多态

interface Fu {}

class Zi implements Fu {}

Fu f = new Zi();

(3)多态中的成员访问特点

A:成员变量

编译看左边，运行看左边

B:构造方法

子类的构造都会默认访问父类构造

C:成员方法

编译看左边，运行看右边

D:静态方法

编译看左边，运行看左边

为什么?

因为成员方法有重写。

(4)多态的好处：

A:提高代码的维护性(继承体现)

B:提高代码的扩展性(多态体现)

(5)多态的弊端：

父不能使用子的特有功能。

现象：

子可以当作父使用，父不能当作子使用。

(6)多态中的转型

A:向上转型

从子到父

B:向下转型

从父到子

11、抽象类

(1)把多个共性的东西提取到一个类中，这是继承的做法。

但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。

也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。

所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。

而一个没有具体的方法体的方法是抽象的方法。

在一个类中如果有抽象方法，该类必须定义为抽象类。

(2)抽象类的特点

A:抽象类和抽象方法必须用关键字abstract修饰

B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

C:抽象类不能实例化

D:抽象类的子类

a:是一个抽象类。

b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。

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

A:成员变量

有变量，有常量

B:构造方法

有构造方法

C:成员方法

有抽象，有非抽象

(4)抽象类的几个小问题

A:抽象类有构造方法，不能实例化，那么构造方法有什么用?

用于子类访问父类数据的初始化

B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?

为了不让创建对象

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

a:final冲突

b:private 冲突

c:static 无意义

12、接口

(1)回顾猫狗案例，它们仅仅提供一些基本功能。

比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，

是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。

(2)接口的特点：

A:接口用关键字interface修饰

interface 接口名 {}

B:类实现接口用implements修饰

class 类名 implements 接口名 {}

C:接口不能实例化

D:接口的实现类

a:是一个抽象类。

b:是一个具体类，这个类必须重写接口中的所有抽象方法。

(3)接口的成员特点：

A:成员变量

只能是常量

默认修饰符：public static final

B:构造方法

没有构造方法

C:成员方法

只能是抽象的

默认修饰符：public abstract

(4)类与类,类与接口,接口与接口

A:类与类

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

B:类与接口

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

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

C:接口与接口

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

13、常见的修饰符

(1)分类：

权限修饰符：private,默认,protected,public

状态修饰符：static,final

抽象修饰符：abstract

(2)常见的类及其组成的修饰

类：

默认,public,final,abstract

常用的：public

成员变量：

private,默认,protected,public,static,final

常用的：private

构造方法：

private,默认,protected,public

常用的：public

成员方法：

private,默认,protected,public,static,final,abstract

常用的：public

14、内部类

(1)把类定义在另一个类的内部，该类就被称为内部类。

举例：把类B定义在类A中，类B就被称为内部类。

(2)内部类的访问规则

A:可以直接访问外部类的成员，包括私有

B:外部类要想访问内部类成员，必须创建对象

(3)内部类的分类

A:成员内部类

B:局部内部类

(4)成员内部类

A:private 为了数据的安全性

B:static 为了访问的方便性

成员内部类不是静态的：

外部类名.内部类名 对象名 = new 外部类名.new 内部类名();

成员内部类是静态的：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

(5)成员内部类的面试题(填空)

//30,20,10

class Outer {
public int num = 10;

class Inner {
public int num = 20;

public viod show() {
int num  = 30;

System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);

答案是 打印 30 ， 20 ，10

(6)局部内部类

A:局部内部类访问局部变量必须加final修饰。

B:为什么呢?因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。所以，堆内存还是用该变量，而改变量已经没有了。
为了让该值还存在，就加final修饰。加入final后，堆内存直接存储的是值，而不是变量名。

(7)匿名内部类

A:是局部内部类的简化形式

B:前提存在一个类或者接口

C:格式:new 类名或者接口名() {重写方法;}

D:本质：其实是继承该类或者实现接口的子类匿名对象(8)匿名内部类在开发中的使用我们在开发的时候，会看到抽象类，或者接口作为参数。

而这个时候，我们知道实际需要的是一个子类对象。如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

interface Person {
public abstract void study();
}

class PersonDemo {
public void method(Person p) {
p.study();
}
}

class PersonTest {
public static void main(String[] args) {
PersonDemo pd = new PersonDemo();
pd.method(new Person() {
public void study() {
System.out.println("好好学习，天天向上");
}
});
}
}

15、异常

(1)程序出现的不正常的情况

(2)异常的体系

Throwable

|--Error 严重问题，我们不处理

|--Exception

|--RuntimeException运行期异常，我们需要修正代码

|--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过

(3)异常的处理

A:JVM的默认处理

把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了

B:自己处理

a:try...catch...finally

自己编写处理代码,后面的程序可以继续执行

b:throws

把自己处理不了的，在方法上声明，告诉调用者，这里有问题

(4)面试题

A:编译期异常和运行期异常的区别?

编译期异常 必须要处理的，否则编译不通过

运行期异常 可以不处理，也可以处理

B:throw和throws是的区别

throw:

在方法体中,后面跟的是异常对象名,并且只能是一个

throw抛出的是一个异常对象，说明这里肯定有一个异常产生了

throws:

在方法声明上,后面跟的是异常的类名,可以是多个

throws是声明方法有异常，是一种可能性，这个异常并不一定会产生

(5)finally关键字及其面试题

A:finally用于释放资源，它的代码永远会执行。特殊情况：在执行到finally之前jvm退出了

B:面试题

a:final,finally,finalize的区别?

b:如果在catch里面有return,请问finally还执行吗?如果执行,在return前还是后

会，前

C:异常处理的变形

try...catch...finally

try...catch...

try...catch...catch...

try...catch...catch...fianlly

try...finally

(6)自定义异常

继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可

(7)异常的注意实现

A:父的方法有异常抛出,子的重写方法在抛出异常的时候必须要小于等于父的异常

B:父的方法没有异常抛出,子的重写方法不能有异常抛出

C:父的方法抛出多个异常,子的重写方法必须比父少或者小