一、面向对象简介
(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:父的方法抛出多个异常,子的重写方法必须比父少或者小