类与对象(复习)
1.面向对象学习的三条主线:
① Java类及类的成员:属性、方法、构造器;代码块、内部块
② 面向对象的三大特征:封装性、继承性、多态性、(抽象性)
③ 其他关键字:this、super、static、final、abstract、interface、package、import等
“大处着眼,小处着手”
2.面向对象与面向过程(理解)
①面向对象:强调具备了功能的对象,以类/对象为最小单位,考虑谁来做
②面向过程:强调的是功能行为,以函数为最小单位,考虑怎么做
3.完成一个项目(或功能)的思路:
①根据问题需要,选择问题所针对的现实世界中的实体。
②从实体中寻找解决问题相关的属性和功能,这些属性和功能就形成了概念世界中的类。
③把抽象的实体用计算机语言进行描述,形成计算机世界中类的定义。即借助某种程序语言,把类构造成计算机能够识别和处理的数据结构。
④将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。
4.面向对象中的两个重要的概念:
类:对一类事物的描述,是抽象的、概念上的定义。
对象:是实际存在的该类事物的每个个体,因而也称为实例(instance)
面向对象程序设计的重点是类的设计
设计类,就是设计类的成员
二者的关系:
对象,是由类new出来的,派生出来的
5.面向对象思想落地实现的规则:
1.创建类,设计类的成员
2.创建类的对象
3.通过“对象.属性”或“对象.方法”调用对象的结构
补充:几个概念的使用说明:
属性 = 成员变量 = field = 域、字段
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类
public class Persontest {
public static void main(String[] args) {
//创建Person类的对象
Person p1 = new Person();
//调用对象的结构:属性、方法
//调用属性
p1.name = "Tom";
p1.isMale = true;
System.out.println(p1.name);
//调用方法
p1.eat();
p1.sleep();
p1.talk("Chinese");
//*******************************************
Person p2 = new Person();
System.out.println(p2.name);
System.out.println(p2.isMale);
//*******************************************
//将p1变量保存的对象地址付给p3,导致p1和p2指向堆空间中的同一个对象实体。
Person p3 = p1;
System.out.println(p3.name);//tom
p3.age = 10;
System.out.println(p1.age);//10
}
}
class Person{
//属性
String name;
int age = 1;
boolean isMale;
//方法
public void eat() {
System.out.println("人可以吃饭");
}
public void sleep(){
System.out.println("人可以睡觉");
}
public void talk(String language) {
System.out.println("人可以说话,使用的是:"+ language);
}
}
6.对象的创建与对象的内存解析
典型代码:
Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象,共用一个堆空间中的对象实体。
说明:
如果创建一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非static的)
意味着:如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值。
内存解析:
7.匿名对象
理解:我们创建一个对象,没有显示的赋给一个变量名。即为匿名对象
特点:匿名对象只能调用一次。举例:
new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();应用场景:
PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
其中:
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}
8.理解“万事万物皆对象”
1.在Java语言范畴中,我们都将功能、结构等封装到类中,通过类的实例化,来调用具体的功能结构
Scanner,String等
文件:file
网络资源:URL2.涉及到Java语言与前端Html、后端的数据库交互时,前后端的结构在Java层面交互时,都体现为类、对象
JVM内存结构
编译完源程序以后,生成一个或多个字节码文件。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着,需要将字节码文件对应的类加载到内存中,涉及到内存解析。
虚拟机栈,即为平时提到的栈结构。我们将局部变量存储到栈结构中。
堆,我们将new出来的结构(比如:数组、对象)加载在堆空间中。补充:对象的属性(非static的)加载在堆空间中。
方法区:类的加载信息、常量池、静态域。
类的结构之一:属性
对比:属性 vs 局部变量
①相同点:
1.1定义变量的格式:数据类型 变量名 = 变量值;
1.2先声明,后使用
1.3变量都有其对应的作用域
②不同点:
2.1 在类中声明的位置的不同
属性:直接定义在类的一对{}内
局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2.2 关于权限修饰符的不同
属性:可以在声明属性时,指明其权限,使用权限修饰符。
常用的权限修饰符:private、public、缺省、protected —>封装性
局部变量:不可以使用权限修饰符
2.3 默认初始化值的情况:
属性:类的属性,根据其类型,都有默认初始化值。
整型(byte、short、int、long):0
浮点型(float、double):0.0
字符型(char):0(或‘\u0000’)
布尔型(boolean):false
引用数据类型(类、数组、接口):null
局部变量:没有默认初始化值。
意味着,我们在调用局部变量之前,一定要显示赋值。
特别地:形参在调用时,我们赋值即可。
2.4 在内存中加载的位置:
属性:加载到堆空间(非static)
局部变量:加载到栈空间
public class UserTest {
public static void main(String[] args) {
User u1 = new User();
System.out.println(u1.name);
System.out.println(u1.age);
System.out.println(u1.isMale);
u1.talk("日语");
u1.eat();
}
}
class User{
//属性(成员变量)
String name;
int age;
boolean isMale;
public void talk(String language) {//language:形参,也是局部变量
System.out.println("我们使用"+ language +"进行交流");
}
public void eat() {
String food = "烙饼";//局部变量
System.out.println("北方人喜欢吃" + food);
}
补充:回顾变量的分类:
方式一:按照数据类型:
方式二:按照在类中声明的位置:
类的结构之一:方法
方法:描述类应该具有的功能。
比如: Math类:sqrt()\random()…
Scanner类:nextXxx()…
Arrays类:sort() \ binarySearch() \ toString() \ equals()…1.举例:
public void eat() {}
public void sleep(int hour) {}
public String getName() {}
public String getNation(String nation) {}2.方法的声明:
权限修饰符 返回值类型 方法名(形参列表){
方法体
}
注意:static、final、abstract 来修饰的方法,后面讲3.说明:
3.1关于权限修饰符:
Java规定的4种权限修饰符:private、public、缺省、protected —>封装性3.2返回值类型:有返回值 vs 没有返回值类型
3.2.1如果方法有返回值,则必须在方法声明时,指定返回值的类型。同时这个方法中,需要使用
return关键字来返回指定类型的变量或常量:“return 数据;”
如果方法没有返回值,则方法声明时,使用void来表示。通常,没有返回值的方法中,就不
需要使用return,但是,如果使用的话,只能用“return;”表示结束此方法的意思
3.2.2我们定义方法该不该有返回值?
① 题目要求
② 凭借经验
3.3 方法名:属于标识符,遵循标识符的规则和规范,“见名知意”
3.4 形参列表:方法可以声明0个、1个、或多个形参。
3.4.1 格式:数据类型1 形参1,数据类型2 形参2,…
3.4.2 我们定义方法时,该不该定义形参?
① 题目要求
② 凭借经验
3.5 方法体:方法功能的体现。4.return关键字的使用:
1.适用范围:使用在方法体中
2.作用:① 结束方法
② 针对于有返回值类型的方法,使用"return 数据"方法返回所要的数据。
3.注意点:return关键字后面不可以声明执行语句。5.方法的使用:
可以调用当前类的属性或方法
特殊的:方法A中又调用了方法A:递归方法
方法中,不可以定义方法
public class CustomerTest {
public static void main(String[] args) {
Customer cust1 = new Customer();
cust1.eat();
cust1.sleep(8);
cust1.getNation("China");
}
}
//客户类
class Customer{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat() {
System.out.println("客户吃饭");
return;
//return后不可以声明表达式
}
public void sleep(int hour) {
System.out.println("休息了"+ hour + "个小时");
eat();
}
public String getName() {
return name;
}
public String getNation(String nation) {
String info = "我的国籍是:"+ nation;
System.out.println(info);
return info;
}
}
关键字:return
return关键字的使用:
1.适用范围:使用在方法体中
2.作用:① 结束方法
② 针对于有返回值类型的方法,使用"return 数据"方法返回所要的数据。
3.注意点:return关键字后面不可以声明执行语句。
方法的重载
1.方法的重载的概念
定义:在同一类中,允许存在一个以上的同名方法,只要他们的参数个数或者参数类型不同即可。
总结:“两同一不同”:同一类、同一方法名。
参数列表不同:参数个数不同、参数类型不同
2.构成重载的举例
举例一:Arrays类中重载的sort() / binarySearch;
举例二:
3.如何判断是否构成重载?
严格按照定义判断:两同一不同
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系!
4.如何确定类中某一个方法的调用
方法名→参数列表
可变个数形参的方法
1.使用说明
1.jdk 5.0新增内容
2.具体使用:2.1 可变个数形参的格式:数据类型 … 变量名
2.2 当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个,…
2.3 可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载
2.4 可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载。换句话说,二者不能够共存。
2.5 可变个数形参在方法的形参中,必须声明在末尾!2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
2.举例说明
调用时:
Java的值传递机制
1.针对于方法内变量的赋值举例:
System.out.println("***********基本数据类型***************");
int m = 10;
int n = m;
System.out.println("m = "+ m + ", n = " + n);
n = 20;
System.out.println("m = "+ m + ", n = " + n);
System.out.println("****************引用数据类型****************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后,o1和o2的地址值相同,都指向了堆空间中同一个实体
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " + o2.orderId);
规则:
如果变量是基本数据类型,此时赋值的是变量所保存的数据值。
如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。
2.针对于方法的参数概念
形参:方法定义时,声明的小括号内的参数
实参:方法调用时,实际传递给形参的数据
3.Java中参数传递机制:值传递
规则:
如果参数是基本数据类型,此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值。推广:
如果变量是基本数据类型,此时赋值的是变量所保存的数据值。
如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。
4.典型例题与内存解析
【例题一】:基本数据类型
【例题二】:引用数据类型
递归方法
1.定义:
一个方法体内调用它自身。
2.如何理解递归方法?
方法递归包含了一种隐式的循环,它会重复执行某段代码,但这种重复执行无法循环控制。
递归一定要向已知方向递归,否则这种递归就变成了无穷递归,类似于死循环。
3.举例:
//例1:计算1-n之间所有自然数的和
public int getSum(int n) {
if(n == 1) {
return 1;
}else {
return n + getSum(n-1);
}
}
//例2:计算1-n之间所有自然数的乘积
public int getSum1(int n) {
if(n == 1) {
return 1;
}else {
return n * getSum1(n-1);
}
}
//例3.已知有一个数列:f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0
//的整数,求f(10)的值。
public int f(int n) {
if(n == 0) {
return 1;
}else if(n == 1){
return 4;
}else {
// return f(n + 2) - 2 * f(n + 1);
return 2 * f(n - 1) + f(n - 2);
}
}
面向对象的特征一:封装性
1.为什么要引入封装性?
我们程序设计追求“高内聚,低耦合”
高内聚:类的内部数据操作细节自己完成,不允许外部干扰。
低内聚:仅对外部暴露少量的方法用于使用。隐藏对象内部的复杂性,只对外公开简单的接口。便于外界调用,从而提高系统的可扩展性、可维护性。通俗的说,把该隐藏的隐藏起来,该暴露的暴露出来。这就是封装性的设计思想。
2.问题引入
其一:
当我们创建一个类的对象以后,我们可以通过"对象.属性"的方式,对对象的属性进行赋值。这里,赋值操作要受到属性的数据类型和存储范围的制约。除此之外,没有其他制约条件。但是,在实际问题中,我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现,我们只能通过方法进行限制条件的添加。(比如:setLegs())同时,我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有(private).
—>此时,针对于属性就体现了封装性。
3.封装性思想具体的代码体现
体现一:将类的属性xxx私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值。
体现二:不对外暴露的私有的方法
体现三:单例模式(将构造器私有化)
体现四:如果不希望类在包外被调用,可以将类设置为缺省的
4.Java规定的4种权限修饰符
权限从小到大顺序:private < 缺省 < protected < public
具体的修饰范围:
权限修饰符可以用来修饰的结构说明:4种权限都可以用来修饰类的内部结构:属性、方法、构造器、内部类
修饰类的话,只能使用:缺省、public
类的结构之三:构造器
1.构造器(或构造方法):Constructor
构造器的作用:
1.创建对象
2.初始化对象的信息
2.使用说明
1.如果没有显式的定义类的构造器的话,则系统默认提供一个空参的构造器。
2.定义构造器的格式:权限修饰符 类名(形参列表){}
3.一个类中定义的多个构造器,彼此构成重载。
4.一旦我们显式的定义了类的构造器之后,系统就不再提供默认的空参构造器。
5.一个类中至少会有一个构造器。
3.举例
//构造器
public Person() {
System.out.println("Person().....");
}
public Person(String n) {
name = n;
}
public Person(String n,int a) {
name = n;
age = a;
}
属性赋值顺序
总结:属性赋值的先后顺序
①默认初始化
②显式初始化
③构造器中赋值
④通过"对象.方法"或"对象.属性"的方式以上操作的先后顺序:①一②一③一④
JavaBean的概念
JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean,是指符合如下标准的Java类:
类是公共的
有一个无参的构造器
有属性,且有对应的get、set方法
关键字:this
1.this可以用来修饰、调用: 属性、方法、构造器
2.this修饰属性和方法:
this理解为:当前对象 或 当前正在创建的对象
2.1 在类的方法中,我们可以使用"this.属性"或"this.方法"的方式,调用当前对象属性或方法。
但是,通常情况下,我们都选择省略"this."。
特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用"this.变量"的方法,来表明此变量是属性,而非形参。2.2 在类的构造器中,我们可以使用"this.属性"或"this.方法"的方式,调用当前正在创建的对象属性或方法。
但是,通常情况下,我们都选择省略"this."。
特殊情况下,如果构造器的形参和类的属性同名时,我们必须显式的使用"this.变量"的方法,来表明此变量是属性,而非形参。
3.this调用构造器:
① 我们在类的构造器中,可以显式的使用"this(形参列表)"方式,调用本类中指定的其他构造器。
② 构造器中不能通过"this(形参列表)"方式调用自己。
③ 如果一个类中有n个构造器。则最多有n - 1构造器中使用"this(形参列表)"方式
④ 规定:"this(形参列表)"必须声明在当前构造器的首行
⑤ 构造器内部,最多只能声明一个"this(形参列表)"方式,用来调用其他的构造器
关键字:package/import
1.package关键字的使用
1.为了更好地实现项目中类的管理,提供包的概念
2.使用package声明类或接口所属的包,声明在源文件的首行
3.包,属于标识符,遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
4.每“.”一次,就代表一层文件目录
补充: 同一个包下,不能命名同名的接口、类。
不同的包下,可以命名同名的接口、类。
2.举例
举例一:
举例二:MVC设计模式
3.JDK中的主要包介绍:
4.import的使用
import:导入
1.在源文件中显式的使用import结构导入指定包下的类、接口
2.声明在包的声明和类的声明之间
3.如果需要导入多个结构,则并列写出即可。
4.可以使用"xxx."的方式,表示可以导入xxx包下的所有结构
5.如果使用的类或接口时java.lang包下定义的,则可以省略import结构
6.如果使用的类或接口是本包下定义的,则可以省略import结构
7.如果在源文件中,使用不同包下的同名的类,则必须至少有一个类需要以全类名的方式显示。
8.使用"xxx."方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构,则仍需要显式导入。
9.import static: 导入指定类或接口的静态结构