第七章:面向对象
一、编程思想
1.
面向过程:
}
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"\t");
}
(2)
第二种:借助工具类
java.util.Arrays.sort(
数组名
);
(1)
面向过程:将问题分为第一步、第二步、第三
步
...
直到问题解决
(2)
问题:解决小业务相对比较简单,但是面对复
杂业务时,相对不好处理
2.
面向对象:
二、对象
1.
对象:计算机中的对象:复杂的客观事物在
Java
程序中的一种表现形式
2.
对象的组成部分:
(1)
面向对象:将一些业务过程看成一个整体,利
用对象之间关系,解决问题
(2)
好处:解决业务复杂问题时,相对简单
一切皆对象
(1)
对象的属性:代表对象有什么特征,对应静态
数据部分
(2)
对象的方法:代表对象能做什么,对应动态的
行为和功能
3.
类:
三、类的组成
1.
类名:望文生义,每个单词首字母大写
2.
类的组成:
3.
属性:
(1)
计算机中,使用类进行区分不同类别对象,用
于描述该类对象有哪些属性和哪些方法
(2)
类和对象的关系:
类是对象的模板
对象是类的实例
注意:一个类可以创建多个对象
class
类名
{
// 1.
属性
// 2.
方法
}
(1)
属性:也称为成员变量
(2)
位置:定义类以内,方法以外
(3)
语法:数据类型 变量名
;
数据类型 变量名
=
值
;
(4)
成员变量具有默认值:
整数类型:
0
小数类型:
0.0
布尔类型:
false
字符类型:空字符
对象类型:
null
(5)
成员变量的作用范围:至少在本类中有效
(6)
一个类中不允许成员变量命名相同,但是成员
变量可以和局部变量命名冲突;局部变量在方法中
被优先使用
4.
方法:
(1)
方法:也称为成员方法
(2)
位置:定义在类以内,其他的方法以外
(3)
语法:
public
返回值类型 方法名
(
形参
){
//
方法体
}
(4)
方法的定义分为方法的声明和方法实现:
a.
方法的声明:
修饰符 返回值类型 方法名
(
形参
)
异常
注意:一个方法的修饰符可以有
0~n
个
b.
方法的实现:
{}
5.
创建对象:
(1)
类名 对象名
= new
类名
();
(2)
使用:
对象名
.
属性名
对象名
.
方法名
(
实参
);
四、方法的重载
(overload)
【开发
+
面试
+
考试】
1.
理解:一个类中可以定义多个同名的方法,但是
参数列表不同
2.
要求:
3.
使用:根据调用时,传递的实际参数决定调用哪
一个方法
五、构造方法
1.
构造方法:是一种特殊的方法,也被称为构造器
2.
定义位置:定义类以内,方法以外
3.
特点
(
要求
)
(1)
方法名相同
(2)
形参列表不同
(
数据类型、个数、顺序
)
(3)
返回值类型、修饰符、异常没有要求
(1)
构造方法的方法名必须和类名一致
(2)
构造方法没有返回值类型
(
连
void
都没有
)
(3)
语法:
修饰符 类名
(
形参
){}
(4)
构造方法允许重载
(
一个类中可以定义多个构造方法,但是无参
数的构造方法只能一个,可以同时定义多个有参数
的构造方法
)
(5)
构造方法不能手动调用,在创建对象时,被调
用
4.
使用:
(1)
在创建对象时,根据传递的实际参数,决定具
体调用哪一个构造方法完成对象的创建
(2)
如果一个类中没有提供任何的构造方法时,
jvm
默认提供一个公开的无参数的构造方法;当类
中提供了有参数的构造方法,则默认的构造方法不
再提供
(
可以自定义写出
)
5.
构造方法的作用:
6.
开发应用技巧:
六、
this
的应用
1. this.
(1)
用于创建对象
(2)
借助构造方法给属性赋值
实际开发一个类中通常提供两个构造方法:
(1)
一个无参数的构造方法
(2)
一个有参数的构造方法
(
参数取决于属性的个
数、类型、顺序
)
(1) this
代表当前对象,用于调用本类中属性或
是方法
(2) this.
属性名
this.
方法名
(
实参
);
(3) this.
通常可以省略,但是当成员变量和局部
变量命名冲突时,可以使用
this.
区分成员变
量
2. this()
七、引用
1.
引用:对象类型的变量
2.
引用存储对象在堆空间中首地址
3.
每个对象在堆空间是相互独立,操作一个对象不
会影响其他对象
(1) this()
只能应用在构造方法中,调用本类其
他构造方法
(2) this()
只能应用在构造方法中的第一行有效
语句
java
是一种强类型的语言,对应类型的数据需要
存储在对应类型的变量中:
类名 引用名
= new
类名
(
实参
);
//
引用
对象
//
引用类型
对象的类型
注意:引用的类型必须和对象的类型一致
4.
可以单独的声明引用: 类名 引用名
;
5.
相同类型的引用之间可以相互赋值,传递的是对
象在堆空间中首地址
6.
可以利用
null
作为引用的初始化数据,代表空地
址,但是如果使用存储
null
引用调用属性或是方
法,编译通过,但是运行报错,错误信息为:
java.lang.NullPointerException(
空指针异常
)
7.
引用的应用场景:
(1)
引用应用在形式参数上:该类型的对象和引用
都可以作为实际参数进行传递
(2)
引用应用在返回值类型上:该类型的对象或是
引用都可以作为返回值进行返回
第八章:面向对象的三大特性
(
封装、继
承、多态
)
一、封装
1.
目前的程序无法保证数据的安全性、容易造成业
务数据的错误
2. private
:私有的,被
private
修饰的内容只能在
本类中访问
3.
为私有化的属性提供公开的
get
和
set
方法:
二、继承
(
1
)
get
方法,获取私有化属性的值:
public
返回值类型
get
属性名
(){
return
属性名
;
}
注意:返回值类型取决于获取属性的类型
方法名:
get+
属性名首字母大写
(2) set
方法,为私有化属性赋值:
public void set
属性名
(
数据类型 变量
名
){
this.
属性名
=
变量名
}
注意:
()
中的数据类型取决于属性类型
方法名:
set+
属性名首字母大写
碳素笔
是一种
笔
水杯
是一种
容器
狗
是一种
动物
A is a B
如果
A is-a B
关系成立,
A
和
B
之间具有继承关
系
A-
子类
继承
B-
父类
extends
1.
理解:
(1)
继承体现的是类之间的一种
“is-a”
关系。
A is a B
子类
父类
子类
继承
父类
extends
(2)
语法:
class
子类类名
extends
父类类名
{}
(3)
通过继承关系,子类型可以直接使用父类中定
义的属性和方法
2.
继承体现了程序的复用性和可扩展性
3.
方法的覆盖【也被称为方法的重写
- override
】
(1)
方法的覆盖:子类中定义和父类中相同的方法
(2)
方法的覆盖要求:
a.
子类的方法名、形参列表、返回值类型必须和
父类一致
b.
子类的访问修饰符,和父类相同或是比父类更
宽
(3)
如果子类覆盖了父类中方法,则优先使用子类
覆盖后的
(4)
注意:如果子类定义了和父类方法名、形参列
表相同,但是返回值类型不同的方法,则编译报错
(5)
如果子类定义了和父类方法名相同、形参列表
不同的方法,则编译通过,运行也
ok
,这构成了方
法的重载
4. Java
中继承特点:
(1)
一个父类可以有多个直接的子类
class Animal{}
class Dog extends Animal{}
class Cat extends Animal{}
(2)
一个子类只能有一个直接的父类,但是可以有
多个间接的父类
(
多级继承
)
,
java
中的类之间是单
继承
5. java
中的访问修饰符:
(1)
访问修饰符代表一种访问权限
(2) java
中有
4
个访问修饰符:
private
:私有的
default
:默认的
protected
:受保护的
public
:公开的
(3)
访问修饰符的访问权限:
本类
同包
非同包的子类
其他
private ok
default ok ok
protected ok ok ok
public
:
ok ok ok
ok
(4)
访问修饰符修饰内容的继承性:
private
修饰的属性和方法,不能被继承
default
修饰的属性和方法,同包子类允许
继承
protected
修饰的属性和方法,同包
+
非同
包子类继承
public
修饰的属性和方法,所有子类都可以
继承
6. super
的应用:
三、多态
1.
理解:
(1)
第一种用法:
super.
a. super.
引用在子类的方法中,代表访问
父类中属性或是成员方法
b. super.
属性名
super.
成员方法名
(
实参
);
(2)
第二种用法:
super()
a.
创建子类对象时,
jvm
默认创建一个父类
对象,而且默认使用父类中无参数的构造方法完成
父类对象的创建
b. super()/super(
实参
):
应用在子类的
构造方法的第一行有效语句中,代表创建子类对象
时,告知
jvm
完成父类对象创建时采用哪一个构造
方法完成对象的创建
c.
如果子类的构造方法第一行没有指定
super()/super(
实参
)
,则默认添加
super()
(1)
多态:父类型的引用存储不同子类型的对象
父类类名 引用名
= new
子类类名
();
引用
对象
父类型
子类型
(2)
使用父类型的引用调用属性或是方法,只能调
用父类中定义的属性和方法
(3)
如果子类覆盖了父类中方法,则优先使用子类
覆盖后的方法
2.
引用之间的转换:
(1)
父类型的引用赋值给子类型的引用,需要强制
类型转换
大类型
小类型
a.
子类类名 引用名
= (
子类类名
)
父类型
的引用名
;
b.
强制类型转换的结果:
i.
实际存储的对象类型和要转换类型一
致,编译
+
运行通过
ii.
实际存储的对象类型和要转换的类型
不一致,编译通过,运行报错,错误信息为:
java.lang.ClassCastException(
类型转换异
常
)
(2)
子类型的引用 赋值给父类型的引用,无需强
转,直接赋值,体现多态
(3)
没有继承关系双方,不允许相互赋值,强制类
型转换也不允许
3. instanceof
避免类型转换异常:
(1)
语法:引用名
instanceof
类名
(2)
执行:判断引用中存储的实际对象类型是否兼
容于后面的类型
(
是否为后面类型的一种
)
,兼容
-
true
,不兼容
-false
(3)
作用:可以在程序设计中避免类型转换异常
直接使用案例中的
Animal
、
Dog
、
Cat
类即可,
在
main
函数中完成以下功能:
public static void main(String[]
arsg){
Animal a = null;
/*
利用
Scanner
输入一个整数
n
,
n
是偶数
则存储
Dog,
否则存储
Cat
*/
/*
判断:如果
a
中存储的是
Cat
,打印输
出
"
我是猫
"
,
否则打印输出
"
我不是猫
"
4.
多态的应用:
第九章:三个修饰符
一、
abstract[
抽象的
]
1. abstract
可以修饰类:
*/
}
(1)
多态应用在形式参数上:本类型
+
所有的子类
型对象、引用都可以作为实际参数进行传递
(2)
多态应用在返回值上:本类型
+
所有子类型的
对象、引用都可以作为返回值进行返回
(1)
被
abstract
修饰的类称为抽象类
(2)
语法:
abstract class
类名
{}
(3)
特点:抽象类只能声明引用,不能创建对象
(4)
抽象类中可以定义属性和成员方法、构造方法
2. asbtract
可以修饰方法:
(1)
被
asbtract
修饰的方法称为抽象方法
(2)
语法:
访问修饰符
abstract
返回值类型 方法名
(
形参
);
注意:访问修饰符和
abstract
没有先后顺序
(3)
特点:抽象方法只有声明部分,没有方法的实
现
(4)
注意:抽象方法只能定义在抽象类中
3.
抽象可以定义子类
(1)
语法:
class
类名
extends
抽象类类名
{}
(2)
特点:子类不想成为抽象类,则必须覆盖父类
中所有的抽象方法
二、
static[
静态的
]
1.
可以修饰属性:
2.
3.
可以修饰方法:
(1)
被
static
修饰的属性称为静态属性、静态变
量、类变量
(2)
语法:
static
数据类型 变量名
;
static
数据类型 变量名
=
值
;
(3)
特点:静态变量基于类存在,被所有对象共
享,和创建对象的多少无关
(4)
使用:
a.
可以通过 对象
.
静态属性名
b.
可以直接通过 类名
.
静态属性名
->
建
议
(1)
被
static
修饰的方法称为静态方法
(2)
语法:
访问修饰符
static
返回值类型 方法名
(
形
参
){}
(3)
使用:直接通过 类名
.
静态方法名
(
实参
);
(4)
注意:静态方法中只能访问本类的静态成员,
不能直接访问本类的非静态成员
(5)
静态方法中不能使用
this
和
super
关键字
4.
可以代码块
(1)
被
static
修饰的代码称为静态代码块
(2)
位置:定义在类以内,方法以外,被
static
修饰的
{}
(3)
语法:
class
类名
{
static{}
}
(4)
作用:在类加载的时候,静态代码块按照和属
性定义的先后顺序完成对静态属性的初始化工作
(5)
类加载:当
jvm
第一次使用一个类的时候,通
过
classpath
找到类对应的
.class
文件,对文件
进行读取
,
读取该类的包名、类名、父类、属性、构
造方法等信息,并将读取的信息保存到
jvm
内存
中,一个类进行一次类加载。
(6) jvm
类加载的时机
(
什么叫第一次使用一个
类
)
:
a.
第一次访问该类的静态成员
b.
第一次创建该类对象:
先进行类加载,再完成对象的创建
c.
子类类加载,先导致其父类类加载
三、
final[
最终的、最后的
]
1. final
可以修饰变量:
2. final
可以修饰方法:允许子类继承,但是不允许
覆盖
3. final
可以修饰类:被
final
修饰的类不允许被继
承,没有子类,例如:
System
、
Math
第十章:接口
(1)
被
final
修饰的变量作用范围内的常量
(2) final
数据类型 变量名
;
(3)
特点:只允许一次赋值,不允许修改
(4)
注意:引用一旦被
final
修饰,代表引用中存
储的对象不能更换
思考:
System.out.println();
实现原理?
System ->
类
out ->
静态 属性
-
》对象类型
println() ->
方法
一、接口
1.
接口:是一种标准,接口的实现者和使用者都必
须遵循的约定。
2.
接口的语法:
二、接口的实现类
1.
语法:
(1)
接口的关键字:
interface
(2)
语法:
interface
接口名
{}
(3)
接口不能创建对象,但是可以声明引用
(4)
接口中不能定义构造方法
(5)
接口中所有属性为公开、静态、常量
(
默认被
public static final
修饰
)
(6)
接口中所有方法位公开抽象方法
(
默认被
public asbtract
修饰
)
class
类名
implements
接口名
{}
2.
注意:
(1)
如果实现类不想成为抽象类,需要覆盖接口中
所有的方法
(2)
实现类覆盖接口中方法时,访问权限必须是
public
3.
使用:
接口名 引用名
= new
实现类类名
();
//
父类型
子类型
//
接口
实现类
-
》 体现多态