05Java类与对象
类与对象
事物: 类:
属性 成员变量
行为 成员方法
类:是一组相关的属性和行为的集合。是一个抽象的概念。 学生:类
对象:是该类事物的具体表现形式。具体存在的个体。 班长:对象
1:面向对象思想
面向对象是基于面向过程的编程思想。
面向过程:强调的是每一个功能的步骤
面向对象:强调的是对象,然后由对象去调用功能
2:面向对象的思想特点
A:是一种更符合我们思想习惯的思想
B:可以将复杂的事情简单化
C:将我们从执行者变成了指挥者
3:开发,设计,特征
面向对象开发:就是不断的创建对象,使用对象,指挥对象做事情。
面向对象设计:其实就是在管理和维护对象之间的关系。
面向对象特征:
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
抽象
类、对象、实例的关系
每个 对象 都是某个 类 (class)的一个 实例 (instance)。
对象是类实例化的结果 –> 类定义了一个数据类型,而对象是该数据类型的一个实例化。
类中的成员
成员变量和局部变量的区别
A:在类中的位置不同
成员变量(属性,字段,域,全局变量):在类中方法外声明的变量。用于描述类的特征。
局部变量:在方法定义中或者方法声明上。
B:在内存中的位置不同
成员变量:在堆内存
局部变量:在栈内存
C:生命周期不同
成员变量:随着对象的创建而存在,随着对象的消失而消失
局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
D:初始化值不同
成员变量:有默认初始化值
局部变量:没有默认初始化值,必须定义,赋值,然后才能使用。
注意事项:局部变量名称可以和成员变量名称一样,在方法中使用的时候,采用的是就近原则。
new关键字
在堆中开辟空间,创建类的实例(对象)。
类的每个对象都有自己的成员变量。
成员方法(函数)
用于描述类的行为(动作)。
i. 基本格式:
访问权限 返回类型 方法名([参数列表]){
代码;
}
ii. 当方法不需要返回类型时,使用void关键字表示。
iii. return关键字:
1. 结束方法。
2. 返回数据。
方法的重载
i. 同一个类中**,出现名字相同**,但参数列表不同(个数不同,顺序不同,类型不同)的现象。
ii. 方法的重载与返回类型,访问权限无关。
Override:方法重写
Overload:方法重载
形参与实参
i. 形参为基本数据类型:传递的是值,形参改变,实参不变。
ii. 形参为引用数据类型:传递的是引用,通常形参改变,实参也发生改变。
可变长参数
JDK1.5开始出现。
i. 只能用于形参。
ii. 格式:数据类型… 参数名
iii. 可变长参数的本质:一维数组
iv. 如果方法有多个参数,可变长参数必须出现在最后。
构造方法
又叫 构造器、构造函数。
i. 构造方法的功能(作用):为类的成员变量初始化。
ii. 构造方法的特征:
1. 构造方法的名字与类名相同(普通方法的名字也可以与类名相同)。
2. 构造方法没有返回类型,没有具体的返回值,不能使用void关键字。
iii. 类一定有构造方法。
iv. 构造方法私有将无法创建对象
public class Function {
private Function(){}
}
v. 当没有在类中显式的写构造方法时,JVM会自动为类添加默认的无参构造方法。
默认构造方法:
访问权限与类相同 构造方法名(){
}
当在类中显式的写了构造方法后,JVM不再为类添加默认的构造方法。
vi. 通常,构造方法只能在new关键字后面调用。即构造方法在创建对象时被调用
vii. 构造方法可以重载。
viii.
包(package)
i. 包的本质就是文件夹。
ii. 包的作用:
1. 解决类的重名问题。
2. 管理类。
iii. 当类位于某个包中时,类的首行必须为package语句(注释除外)。
iv. 当使用其它包中的类时,需要使用import语句导入类(导包)。
v. java.lang包中的内容,JVM自动导入。
vi. eclipse中直接创建在src(default package)下的类无法使用import语句导入。
vii. JAVA命名规范:包名均为小写。oracle.jdbc.driver.OracleDriver
创建对象做了哪些事情
匿名对象
匿名对象:没有名字的对象。 //new Student();
匿名对象的应用场景:
A:调用方法,仅仅只调用一次的时候。
这种匿名调用的好处:匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。
new Student().show();
new Student().show(); //这里其实是重新创建了一个新的对象
B:匿名对象可以作为实际参数传递
new StudentDemo().method(new Student());
private、this、super、static关键字
private
i. 是一个权限修饰符
ii. 可以修饰成员(成员变量和成员方法)。被private修饰的成员只能在本类中被访问。构造方法私有将无法创建对象。
this
代表当前类的对象的引用。
引用当前类中的成员变量与成员方法。
只能在构造方法中通过this来调用其他构造方法且要放在首行,普通方法中不能使用。
不能通过this递归调用构造方法。
1 | private String name; |
super
代表父类存储空间的标识。(代表父类的引用,用来访问父类的成员)
- 如果自己用super关键字在子类里调用父类的构造方法,则必须在子类的构造方法中的第一行。
- 如果子类的构造方法中没有显示调用父类的构造方法,则系统默认调用父类无参的构造方法。
- 如果子类构造方法中既没有显示调用父类的构造方法,而父类没有无参的构造方法,则编译出错。
注意:super.getClass() 和 this.getClass() 返回的都是 new 对象时指定的类。
static
修饰成员变量和成员方法
静态的成员可以直接使用类名(接口名)直接调用,也可以通过类的对象调用。
修饰成员变量:静态变量。
i. 类所有的对象共用一份静态变量。
ii. 静态变量只在第一次使用类时初始化,从第二次使用类时不再进行初始化。
修饰成员方法:静态方法。
i. 静态方法不能使用this与super关键字。
ii. 静态方法只能直接调用当前类中静态的成员。想要调用非静态成员必须通过类的对象调用
iii. 非静态的方法可以直接调用静态的成员。
1 | private String name; |
静态的特点
A:随着类的加载而加载
B:优先与对象存在
C:被类的所有对象共享
D:可以通过类名调用:
既可以通过对象名调用,也可以通过类名调用,建议通过类名调用。
静态的内存图
静态的内容在方法区的静态区
静态的注意事项
A:在静态方法中没有this对象
B:静态只能访问静态
静态变量和成员变量的区别
A:所属不同
静态变量:属于类,类变量
成员变量:属于对象,对象变量,实例变量
B:内存位置不同
静态变量:方法区的静态区
成员变量:堆内存
C:生命周期不同
静态变量:静态变量是随着类的加载而加载,随着类的消失而消失
成员变量:成员变量是随着对象的创建而存在,随着对象的消失而消失
D:调用不同
静态变量:可以通过对象名调用,也可以通过类名调用
成员变量:只能通过对象名调用
为什么静态方法中不能使用this与super
static修饰的成员归类所有,this和super代表对象的引用 (有对象才会有引用)。类先于任何实例 (对象) 存在,即 static 修饰的成员在类加载时就已经存在了,但对象在创建时才在内存中生成,所以在静态方法中不能使用 this 与 super 关键字。
对象是类实例化的结果
代码块
1、代码块:在Java中,使用{}括起来的代码被称为代码块。
2、根据其位置和声明的不同,可以分为
局部代码块:局部位置,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前,都会先执行构造代码块。
作用:可以把多个构造方法中的共同代码放到一起,对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用:一般是对类进行初始化。
思考题?
静态代码块,构造代码块,构造方法的执行顺序?
静态代码块 – 构造代码块 – 构造方法
静态代码块:只执行一次
构造代码块:每次调用构造方法都执行
demo1
1 | public class Test { |
demo2
1 | class Fu { |
封装
步骤:
- 类中的成员变量为private(私有)
- 为私有的成员变量提供公有的get()或set()方法。
- getter和setter方法中加入合法性判断等校验
封装的好处:
隐藏实现细节,提供共有的访问方式
提高了代码的复用性
提高安全性
封装的原则(思想):
将不需要对外提供的内容隐藏起来
把属性隐藏,提供公共方法对其访问
封装的体现:private是封装的一种体现。
总结:
- 封装是一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
- 封装被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
- 封装特性要求,访问该类的代码和数据,必须通过严格的接口控制。
- 封装的目的是,在修改代码时只需要修改实现代码片段,而不用修改调用代码片段。
- 适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。
继承(extends)
继承是子类继承父类的特征和行为,能使得
- 子类对象(实例)具有父类的实例域和方法。
- 子类从父类继承方法,使得子类具有父类相同的行为。
格式:
class 子类名 extends 父类名 {}
好处:
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类之间产生了关系,是多态的前提
类与类产生了关系,其实也是继承的一个弊端:类的耦合性增强了。
开发的原则:低耦合,高内聚。
耦合:类与类的关系
内聚:就是自己完成某件事情的能力
Java中的继承体系
Java中使用extends关键字来表示类继承关系。
Java中使用implement关键字来表示接口实现关系。
JAVA是(只支持)单继承:一个类只能有一个直接的父类;接口是多实现。
Java支持多层继承(继承体系),儿子继承父亲,父亲继承爷爷。Java也可使用内部类的方式来实现类的多继承特性。
子类可以继承父类所有的成员变量与成员方法(包括private)。
子类可以继承父类private的成员,但不能使用。子类不能继承父类的构造方法。(可使用super关键字)
若子类和父类中的成员变量或方法名称一样,在子类方法中访问一个变量的查找顺序:
a:在子类方法的局部范围找,有就使用
b:在子类的成员范围找,有就使用
c:在父类的成员范围找,有就使用
d:如果还找不到,就报错。JAVA中类不能确定自己是否被继承。
Java中的继承初始化顺序为: 父类对象属性初始化–>父类对象构造方法–>子类对象属性初始化–>子类对象构造方法
1 | class Father { |
访问权限
类(顶层类)只能使用public与默认的访问权限修饰。
本类 | 同包(同包中的类) | 子类(不同包中的子类) | 其他 | |
---|---|---|---|---|
private | Y | |||
default | Y | Y | ||
protected | Y | Y | Y | |
public | Y | Y | Y | Y |
从上到下:可访问性增强,但封装性变差。
方法的重写(覆盖)
子类根据需要重写父类中的方法。
重写的方法要与被重写的方法具有相同的方法名,参数列表,返回类型。**
重写方法的访问权限要大于等于被重写方法的访问权限。**
重写方法声明的异常必须小于等于被重写方法声明的异常(当父类的方法声明了异常,子类重写的方法可以不声明异常。如果子类重写的方法声明了异常,必须小于等于父类方法声明的异常)。
父类静态方法,子类也必须通过静态方法进行重写。
static不能产生重写,但现象确实如此,为什么算不上方法重写,因为在多态中这种现象不成立。父类中私有(private)方法不能产生重写。(可以被“重写”,没有重写的效果,所以并不叫重写)
对于覆写的方法,我们一般使用**@Override**注解标注,有助于静态检查。
super关键字
在子类中引用父类中的成员(通常,在子类中引用父类同名的成员)。
this和super的用法:
引用成员:
this.成员变量 调用本类的成员变量
super.成员变量 调用父类的成员变量
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
引用构造方法:
this(参数):调用本类中另一种形式的构造函数(应该为构造函数中的第一条语句)。
super(参数):调用父类中的某一个构造函数(应该为构造函数中的第一条语句)。
继承中的构造方法
a) 子类默认会在自己每一个构造方法的第一行使用super()调用父类无参的构造方法。因为如果不是放在第一条语句上,就可能对父类的数据进行了多次初始化。
子类构造方法执行前默认先执行父类的无参构造方法
b) 当父类没有无参的构造方法时,而子类也没有调用父类有参数的构造方法,则编译失败。
多态
- 多态是同一个行为具有多个不同表现形式或形态的能力。
- 多态就是同一个接口,使用不同的实例而执行不同操作。
- 同一个事件发生在不同的对象上会产生不同的结果。
格式
父类声明,子类创建。
父 f = new 子();
多态的前提
A:要有继承关系。
B:要有方法重写。
其实没有也是可以的,但是如果没有这个就没有意义。
C:要有父类引用指向子类对象。
多态时只能调用父类的成员
a) 多态时调用的成员变量一定为父类的成员变量。
b) 多态时调用的成员方法:
i. 如果子类没有重写此方法,调用的是父类的方法。
ii. 如果子类重写了父类的方法,调用的是子类的方法。
c) 多态时调用的构造方法:
创建子类对象的时候,访问父类的构造方法,对父类的数据进行初始化。
d) 多态时调用的static方法
static方法不能产生重写。现象像重写但不是重写,如果子类“重写”static方法,依然调用父类的方法。
多态的好处/特点:
- 替换性:父类的引用可替换成任意子类。
- 扩展性:提高了代码的扩展性(由多态保证),增加新的子类不影响已存在类的多态性、继承性,以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。
- 接口性:父类通过方法签名,向子类提供了一个共同接口,由子类来完善或者覆盖它而实现的。
- 灵活性:在应用中体现灵活多样的操作,提高了使用效率,由继承保证。
- 简化性:简化对应用软件的代码编写和修改过程,在处理大量对象的运算和操作时尤为重要。
多态的弊端
不能使用子类的特有功能。
我就想使用子类的特有功能?行不行?—————-行。
怎么用呢?
创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,太占内存了)
把父类的引用强制转换为子类的引用。(向下转型)
多态的表现形式
引用多态:
- 向上转型:父类引用指向子类对象(父类声明,子类创建)
Fu f = new Zi(); // f是子类型,外界看到的是父类型 - 向下转型:父类引用转为子类对象
Zi z = (Zi)f; // 外界看到的是父类型,强转成子类型后,外界看到是子类型。要求该f必须是能够转换为Zi的,也就是说f本身就是Zi,所以才能转。 - 使用instanceof运算符,判断引用对象的类型,避免类型转换的安全性问题。
方法多态:
- 创建本类对象时,调用本类方法;创建子类对象时,调用为子类重写方法或者继承的方法。
- 重载 (Overload):一个同名方法可以传入多个参数组合。
- 覆写 (Override):由于继承关系中的子类有一个和父类同名同参数的方法,会覆盖掉父类的方法。
- 基本数据类型存在一个方法匹配调用顺序 char -> int -> long -> double,同时也会进行自动装箱,调用包装类方法。
引用数据类型的类型转换
a) 引用数据类型比较大小:父类大,子类小。
b) 子类可以直接赋给父类。
c) 父类必须强转才能赋给子类。
d) 当父类的引用指向的实例,不是需要的子类类型,则运行时发生异常。
e) 当两个类没有继承关系时不能相互转换,否则编译失败。
java.lang.Object
a) 是JAVA中所有类的父类。
b) toString():当输出一个类的对象时,或将类的对象与字符串连接时。JVM会自动调用类的toString().
c) ==与equals()
i. ==:判断栈中的内容是否相等。基本数据类型比较的是值是否相等。引用数据类型比较的是引用是否相等。
ii. equals():判断当前对象与指定对象是否相等(判断堆中的内容是否相等)。equals()最早出现在Object类中,Object中的equals()仍然判断栈中的内容是否相等。如果自定义的类需要判断是否相等时,建议重写Object类中的equals()方法。
抽象类与接口
abstract
a) 修饰类:抽象类,抽象类不能实例化(不能new),只能使用抽象类的子类进行实例化。
抽象类也有构造方法(抽象类的子类需要在自己构造方法的第一行调用父类的构造方法)。
那么问题来了:
抽象类有构造方法,但是不能实例化?构造方法的作用是什么呢?
用于子类访问父类数据的初始化
b) 修饰方法:抽象方法,抽象方法只有方法的声明没有方法的实现。子类必须重写父类中所有的抽象方法(当子类为抽象类时,子类可以不重写父类中的抽象方法或只重写父类中部分的抽象方法)。
抽象方法所在的类必须为抽象类。抽象类中不一定有抽象方法。
c) 修饰接口
d) abstract不能与哪些关键字一起使用:final,private,static,
a:final 冲突
b:private 冲突
c:static 无意义
e) 可以使用final关键字定义方法:
1、修饰类:该类不允许被继承。
2、修饰方法:方法不能被子类重写。
3、修饰属性,则该类的该属性不会进行隐式的初始化,构造方法中必须唯一赋值。
4、修饰变量:该变量只能赋一次值,在声明变量的时候才能赋值,即变为常量。
思考题:final修饰局部变量的问题
基本类型:基本类型的值不能发生改变。
引用类型:引用类型的地址值不能发生改变,但是,该对象的堆内存的值是可以改变的。
f) 阻止类被继承有几种方法:1.用final修饰类。2.使用private修饰构造方法。
总结:
1). 非抽象类的子类可以为抽象类。
2). 下面的抽象类可以new
1 | abstract class Method { |
- 如果一个类里面有抽象方法,那么这个类一定是抽象类。
- 抽象类中抽象方法必须被子类全部实现,如果子类不能全部实现,那么子类必须也是抽象类。
interface
a) 接口的作用:使JAVA实现多继承。
b) 接口的成员:
i. 常量:接口中的常量必须为public static final。声明后必须赋值。
ii. 抽象方法:接口中的方法必须为public abstract的。Java 8 开始有变化: Java 8 默认方法 - 菜鸟 、 Java 5~11 各个版本新特性总结
c) 类与接口的关系:
i. 类可以实现(implements)接口。
ii. 当类实现接口时,类必须重写接口中所有的抽象方法。
iii. 一个类可以实现多个接口。
d) 接口不是类,接口中没有构造方法。
e) 接口不能实例化(不能new)。只能使用接口的实现类 (其实也可以,使用匿名对象时)。
f) 接口与接口之间的关系:
i. 接口可以继承接口。
ii. 一个接口可以继承多个接口。
- Interface可以使用反射的代理方法,但Abstract Class无法实现反射代理。
- Interface里面的方法只能声明,不能有具体的实现。(但在Java 8中引入了default关键字,此关键字标注接口方法后,允许接口进行默认实现)。
- 接口里面的方法也必须全部被子类实现,如果子类不能实现那么子类必须是抽象类。
在实际编程中,建议将继承多用于is-a的关系;将接口看做是has-a关系。抽象类功能较之接口虽多,但扩展性不如接口,优先考虑使用接口来解决问题。
内部类
一个类中嵌套另一个类
- 内部类可分为静态内部类、成员内部类、方法内部类、匿名内部类
- 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类。
- 内部类的方法可以直接访问外部类的所有成员,包括private。
- 内部类可以帮助实现多继承功能,但不建议使用;提倡使用Interface来实现多继承概念。
类、接口 关系
A:类与类
继承关系,只能单继承,可以多层继承
B:类与接口
实现关系,可以单实现,也可以多实现。
还可以在继承一个类的同时,实现多个接口
C:接口与接口
继承关系,可以单继承,也可以多继承
抽象类和接口的区别
A:成员区别
抽象类:
成员变量:可以变量,也可以常量
构造方法:有
成员方法:可以抽象,也可以非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象
B:关系区别:
类与类:继承,单继承
类与接口:实现,单实现,多实现
接口与接口:继承,单继承,多继承
C:设计理念不同
抽象类:is a,定义的是共性功能。
接口: like a,定义的是扩展功能。
形式参数和返回值的问题
形式参数
类名:需要该类的对象
抽象类名:需要该类的子类对象
接口名:需要该接口的实现类对象
案例一:
案例二:
案例三:
返回值类型
类名:返回的是该类的对象
抽象类名:返回的是该类的子类对象
接口名:返回的是该接口的实现类的对象
案例一:
案例二:
案例三:
链式编程
对象.方法1().方法2()…….方法n();
这种用法:其实在方法1()调用完毕后,应该一个对象;
方法2()调用完毕后,应该返回一个对象。
方法n()调用完毕后,可能是对象,也可以不是对象。
案例:
包
就是文件夹
作用
A:区分同名的类
B:对类进行分类管理
a:按照功能分
b:按照模块分
举例:
学生:增加,删除,修改,查询
老师:增加,删除,修改,查询
…
方案1:按照功能分
cn.itcast.add
AddStudent
AddTeacher
cn.itcast.delete
DeleteStudent
DeleteTeacher
cn.itcast.update
UpdateStudent
UpdateTeacher
cn.itcast.find
FindStudent
FindTeacher
方案2:按照模块分
cn.itcast.teacher
AddTeacher
DeleteTeacher
UpdateTeacher
FindTeacher
cn.itcast.student
AddStudent
DeleteStudent
UpdateStudent
FindStudent
包的定义
package 包名;
多级包用.分开。
注意事项
A:package语句必须在文件中的第一条有效语句
B:在一个java文件中,只能有一个package
C:如果没有package,默认就是无包名
带包的编译和运行
A:手动式
a:编写一个带包的java文件。
b:通过javac命令编译该java文件。
c:手动创建包名。
d:把b步骤的class文件放到c步骤的最底层包
e:回到和包根目录在同一目录的地方,然后运行带包运行。
B:自动式
a:编写一个带包的java文件。
b:javac编译的时候带上-d即可
javac -d . HelloWorld.java
c:回到和包根目录在同一目录的地方,然后运行带包运行。
导包
1、我们多次使用一个带包的类,非常的麻烦,这个时候,Java就提供了一个关键字import。
2、格式:
import包名…类名;
另一种:
import包名…*;(不建议)
3、package,import,class的顺序
package > import > class
Package:只能有一个
import:可以有多个
class:可以有多个,以后建议是一个
常见的修饰符
分类
权限修饰符:private,默认,protected,public
状态修饰符:static,final
抽象修饰符:abstract
常见的修饰组成
类:
权限修饰符:默认修饰符,public
状态修饰符:final
抽象修饰符:abstract
常用的:public
成员变量:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
常用的:private
构造方法:
权限修饰符:private,默认的,protected,public
常用的:public
成员方法:
权限修饰符:private,默认的,protected,public
状态修饰符:static,final
抽象修饰符:abstract
常用的:public
例:
另外比较常见的
public static final int X = 10;
public static void show() {}
public final void show() {}
public abstract void show();
内部类
把类定义在另一个类的内部,该类就被称为内部类。
举例:把类B定义在类A中,类B就被称为内部类。
访问规则
A:可以直接访问外部类的成员,包括私有
B:外部类要想访问内部类成员,必须创建对象
分类
A:成员内部类:在成员位置定义的类
B:局部内部类:在局部位置定义的类
成员内部类
A:private 为了数据的安全性
B:static 为了访问的方便性
成员内部类不是静态的:
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
案例1
案例2
成员内部类是静态的:
外部类名.内部类名 对象名 = new 外部类名.内部类名();
案例:
练习题:
1 | // //结果:30,20,10 |
注意:
1:内部类和外部类没有继承关系。
2:通过外部类名限定this对象
Outer.this
局部内部类
A:局部内部类访问局部变量必须加final修饰。
B:为什么呢?
因为局部变量使用完毕就消失,而堆内存的数据并不会立即消失。
所以,堆内存还是用该变量,而该变量已经没有了。
为了让该值还存在,就加final修饰。
通过反编译工具可以知道,加入final后,堆内存直接存储的是值,而不是变量名。
匿名内部类
A:是局部内部类的简化形式
B:前提
存在一个类或者接口
C:格式:
new 类名或者接口名() {
重写方法;
}
D:本质:
其实是继承该类或者实现接口的子类匿名对象
匿名内部类在开发中的使用:
我们在开发的时候,会看到抽象类,或者接口作为参数。
而这个时候,我们知道实际需要的是一个子类对象。
如果该方法仅仅调用一次,我们就可以使用匿名内部类的格式简化。
1 | interface Person { |
匿名内部类的思考题(补齐代码)
1 | interface Inter { |
面向对象分析题
1 | 分析程序看有没有问题,如果有,说出原因即可。 |
总结
1:局部变量和成员变量的区别?
在类中位置不同
在内存中位置不同
生命周期不同
初始化值不同
2:形式参数分别为基本类型和引用类型的问题?
形式参数:基本类型 形参的改变不影响实际参数
形式参数:引用类型 形参的改变直接影响实际参数
如果一个方法的形式参数是一个类的名称,那么这里需要的是该类的对象。
3:匿名对象是什么?应用场景是什么?
没有名字的对象。
应用场景:
A:调用方法,仅仅调用一次的时候
B:作为实际参数传递
4:封装是什么?java中封装的体现有哪些?请举例说明。
封装:隐藏实现细节,提供公共的访问方式。
封装的体现: 类,方法,private修饰成员变量
5:this关键字是什么?this关键字的应用场景?
this:代表当前类的对象应用
应用场景:解决局部变量隐藏成员变量的问题
6:构造方法的作用是什么?构造方法的特点是什么?
构造方法的注意事项是什么?构造方法中可不可以写return语句呢?
作用:用于对对象的数据进行初始化
特点:
A:方法名和类名相同
B:没有返回值类型,连void都不能有
C:没有返回值
注意事项:
A:如果我们不给构造方法,系统就提供一个默认的无参构造方法
B:如果我们给出了构造方法,系统就不再提供默认构造方法
这个时候我们想用,就要自己提供。建议自己提供无参构造方法。
1 | class Student { |
构造方法可以有return语句,但是不能有明确的返回值。也就是说return;
7:给成员变量赋值有几种方式?
A:setXxx()
B:带参构造方法
8:标准的代码编写及测试:
A:学生类的案例
B:手机类的案例
C:长方形类的案例
1 | class Student { |
9:一个类的成员变量初始化过程
Student s = new Student();
A:把Student.class文件加载到内存(类加载器)
B:在栈内存为s开辟空间
C:在堆内存为学生对象申请空间
D:给学生对象的成员变量进行默认初始化
E:给学生对象的成员变量进行显示初始化
F:通过构造方法给学生对象的成员变量进行初始化
G:把堆内存的地址赋值给s变量
10:static关键字是什么?有什么特点?什么时候用呢?
static静态的意思,可以修饰成员变量和成员方法。
特点:
A:随着类的加载而加载
B:优先与对象存在
C:被所有对象共享
D:可以通过类名调用
什么时候用?
A:当一个成员被所有对象共享的时候。
B:工具类的时候。
11:静态变量和成员变量的区别
A:所属不同
B:内存位置不同
C:生命周期不同
D:调用不同
12:main方法各种修饰符及参数的解释?
public:权限修饰符,权限最大
static:可以不用创建对象
void:返回值给jvm无意义
main:一个方法名,大家都默认的
String[] args:接收键盘录入对象
13:Java里关于方法的重写(Override)和重载(Overload),下面说法正确的是 (多选) ABCD
A. 方法重写是指父类与子类之间多态性的一种表现
B. 方法重载是指同一个类中多态性的一种表现
C. 子类中定义的某方法与其父类中的某方法有相同的签名(名称、参数、返回值),称之为方法重写
D. 一个类中定义了多个同名的方法,但方法签名(名称、参数、返回值)不相同,称之为方法重载
14:以下对封装的描述正确的是 D
A. 只能对一个类中的方法进行封装,不能对属性进行封装
B. 如果子类继承了父类,对于父类中进行封装的方法,子类仍然可以直接调用
C. 封装的意义不大,因此在编码时尽量不要使用
D. 封装的主要作用在于对外隐藏内部实现细节,增强程序的安全性
15:下列关于继承的哪项叙述是正确的 D
A. 在java中类允许多继承
B. 在java中一个类只能实现一个接口
C. 在java中一个类不能同时继承一个类和实现一个接口
D. java的单一继承使代码更可靠
回顾1
1:代码块是什么?代码块的分类和各自特点?
2:静态代码块,构造代码块,构造方法的执行流程?
3:继承概述
4:继承的好处
5:Java中继承的特点
6:Java中继承的注意事项?以及我们什么时候使用继承?
7:继承中的成员访问特点
A:成员变量
在子类方法中访问一个变量
B:成员方法
在测试类中通过子类对象去访问一个方法
8:继承中构造方法的执行流程?假如父类没有无参构造方法,子类应该怎么办?
9:面试题
方法重写和方法重载的区别?方法重载能改变返回值类型吗?
Overload
Override
this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
10:继承案例练习
11:猜数字小游戏练习。
通过API学习并使用Math类的random()方法。
回顾2
1:final关键字可以干什么?有什么特点?
最终的意思。可以修饰类,方法,变量。
它修饰类,类不能被继承
它修饰方法,方法不能被重写
它修饰变量,变量是常量
2:final关键字的面试题?
A:修饰局部变量
基本类型:值不能改变
引用类型:地址值不能改变
B:初始化时机
定义的时候
构造方法中
3:多态是什么,前提是什么?
同一个对象在不同时刻表现出来的不同的状态
A:有继承或者实现关系
B:有方法的重写
C:有父类或者父接口引用指向子类对象
4:多态中成员访问的特点?
成员变量
编译看左边,运行看左边
成员方法
编译看左边,运行看右边
静态方法
编译看左边,运行看左边
5:多态的好处及弊端?如何解决多态的弊端?
好处:维护性和扩展性
弊端:父类不能使用子类特有功能
如何解决呢?
A:创建子类对象。(在内存中会多了一个对象)
B:向下转型
6:什么是向上转型?什么是向下转型?
子 - 父
父 - 子
7:多态练习
自己做
8:抽象类概述及其特点?
抽象类:继承的时候,提取了多个方法,而有些方法不是每个子类都是一模一样的实现,
这个时候,就应该把这样的方法不提供具体实现,而不提供具体实现的方法是一个抽象方法。
在一个类中,如果有抽象方法,该类必须定义为抽象类。
特点:
A:抽象类或者抽象方法由abstract修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
D:抽象类的子类
a:是抽象类
b:是具体类,就要重写所有抽象方法
9:抽象类成员特点?
A:成员变量
有变量,有常量
B:构造方法
有。用于子类访问父类数据的初始化
C:成员方法
有抽象方法,有非抽象方法
10:抽象类练习?
11:抽象类的小问题
A:一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
B:abstract不能和哪些关键字共存
final
static
private
12:接口的概述及其特点?
接口:某个继承体系需要扩展功能的时候,就应该实现接口。
特点:
A:接口用interface修饰
B:类实现接口用implements修饰
C:接口不能实例化
D:接口的实现
a:抽象类
b:具体类,重写接口中的所有抽象方法
13:接口的成员特点?
A:成员变量 静态常量
B:成员方法 抽象的
14:抽象类和接口的区别?
A:成员区别
B:关系区别
C:设计理念区别
“is a”
“like a”
回顾3
1:形式参数和返回值问题
形式参数
基本类型
引用类型
返回值类型
基本类型
引用类型
2:包的定义及注意事项
package
第一条有效语句
唯一
3:导包及注意事项
import
java.lang不需要导入
java.xxx.yyy.类名; 导入到类的级别
java.xxx.yyy.*; 这个也可以,但是不建议
4:四种权限修饰符及其特点
5:常见的修饰符及组合
类:public
成员变量:private
构造方法:public
成员方法:public
6:内部类的概述及访问特点
把类定义在另一个类的内部,叫内部类。
访问特点:
内部类可以直接访问外部类的成员,包括私有
外部类访问内部类的成员需要创建对象
7:内部类的分类
按照位置不同:成员内部类、局部内部类
8:匿名内部类的格式和应用及面试题
1 | new 类名或者接口名() { |