1、概述
2、对象的创建和使用
package bjk;
/*
* 一、设计类,其实就是设计类的成员
* 属性 = 成员变量 = field = 域、字段
* 方法 = 成员方法 = 函数 = method
* 创建类的对象 = 类的实例化 = 实例化类
*
* 二、类和对象的使用(面向对象思想落地的实例化)
* 1.创建类,设计类的成员
* 2.创建类的对象
* 3.通过“对象.属性”或“对象.方法”调用对象的结构
*
* 三、如果创建了一个类的多个对象,则每个对象都独立的拥有一套类的属性。(非static的)
* 意味着:如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值。
*
* 四、对象的内存解析
*/
public class PersonTest {
public static void main(String[] args) {
//2.创建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);// 输出:null
System.out.println(p2.isMale);// 输出:false
//**********************************
//将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中同一个对象实体
Person p3 = p1;
System.out.println(p3.name);//输出:Tom
p3.age = 10;
System.out.println(p1.age);//输出:10
}
}
// 1.创建类,设计类的成员
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);
}
}
package bjk;
/*
一、理解“万事万物皆对象”
1.在Java语言范畴中,我们都将功能、结构等封装到类中,通过类的实例化,来调用具体的功能结构。
>Scanner,String等
>文件:File
>网络资源:URL
2.涉及到Java语言与前端Html、后端的数据库交互时,前后端的结构在Java层面交互时,都体现为类、对象。
二、内存解析的说明
1.引用类型的变量,只可能存储两类值:null 或 地址值(含变量的类型)
三、匿名对象的使用
1.理解:我们创建的对象,没有显示的赋给一个变量名,即为匿名对象。
2.特征:匿名对象只能调用一次。
3.使用:如下
*/
public class InstanceTest {
public static void main(String[] args) {
Phone p = new Phone(); //p就是对象的变量名
System.out.println(p);
p.sendEmail();
p.playGame();
//匿名对象
// new Phone().sendEmail();
// new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice(); //结果:0.0
//******************************************
PhoneMall mall = new PhoneMall();
//mall.show(p);
//匿名对象的使用
mall.show(new Phone());
}
}
class PhoneMall{
public void show(Phone phone) {
phone.sendEmail();
phone.playGame();
}
}
class Phone{
double price;//价格
public void sendEmail() {
System.out.println("发送邮件");
}
public void playGame() {
System.out.println("玩游戏");
}
public void showPrice() {
System.out.println("手机价格为:" + price);
}
}
3、内存解析
4、属性声明和使用
package bjk;
/*
* 类中属性的使用
*
* 属性(成员变量) VS 局部变量
* 1.相同点:
* 1.1 定义变量的格式:数据类型 变量名 = 变量值
* 1.2 先声明,后使用
* 1.3 变量都有其对应的作用域
*
* 2.不同点:
* 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);
}
}
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);
}
}
5、方法的声明和使用
package bjk;
/* 类中方法的声明和使用
*
* 方法:描述类应该具有的功能。
* 1.举例:
* public void eat(){}
* public void sleep(int hour){}
* public String getName(){}
* public String getNation(String nation){}
* 2. 方法的声明:权限修饰符 返回值类型 方法名(形参列表){
* 方法体
* }
* 3. 说明:
* 3.1 权限修饰符:
* Java规定的4种权限修饰符:private、public、缺省、protected
* 3.2 返回值类型:有返回值 VS 无返回值
* 3.2.1 如果方法有返回值,则必须在方法声明时,指定返回值的类型。
* 同时,方法中需要使用return关键字来返回指定类型的变量或常量。
* 3.2.2 如果方法没有返回值,则方法声明时,使用void来表示。通常,没有返回值的方法中,
* 就不需要使用return。但是,如果使用的话,只能"return;",表示结束此方法。
* 3.2.3 我们定义方法该不该有返回值?
* ①题目要求②凭经验
* 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);
}
}
//客户类
class Customer{
//属性
String name;
int age;
boolean isMale;
//方法
public void eat() {
System.out.println("客户吃饭");
}
public void sleep(int hour) {
System.out.println("休息了" + hour + "个小时");
eat();
}
public String getName() {
return name;
}
public String getNation(String nation) {
String info = "我的国籍是" + nation;
return info;
}
}
6、方法的重载
/*
方法的重载(overload)
1.定义:在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。
"两同一不同":同一个类、相同方法名
参数列表不同:参数个数不同,参数类型不同
2.举例:
Arrays类中重载的sort() / binarySearch()
3.判断是否是重载:
与方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系!
4.在通过对象调用方法时,如何确定某一个指定的方法:
方法名 ---> 参数列表
可变个数形参的方法
1.jdk 5.0新增的内容
2.具体使用:
2.1 可变个数形参的格式:数据类型... 变量名
2.2 当调用可变个数形参的方法时,传入的参数个数可以是:0个,1个,2个,。。。
2.3 可变个数形参的方法与本类中方法名相同,形参不同的方法之间构成重载。
2.4 可变个数形参的方法与本类中方法名相同,形参类型也相同的数组之间不构成重载,不能共存。
2.5 可变个数形参在方法的形参中,必须声明在末尾,并且最多只能声明一个可变形参。
*/
7、方法参数的值传递机制
关于变量的赋值:
- 如果变量是基本数据类型,此时赋值的是变量所保存的数据值。
- 如果变量是引用数据类型,此时赋值的是变量所保存的数据的地址值。
方法的形参的传递机制:值传递
- 形参:方法定义时,声明的小括号内的参数。
- 实参:方法调用时,实际传递给形参的数据。
- 值传递机制:
如果参数是基本数据类型,此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值。
8、封装性
一、问题的引入:
当我们创建一个类的对象之后,我们可以通过“对象.属性”的方式,对对象的属性进行赋值。这里赋值操作要受到属性的数据类型和存储范围的制约。除此之外,没有其他制约条件。但是,在实际问题中,我们往往要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现,我们只能通过方法进行限制条件的增加。
同时,我们需要避免用户在使用“对象.属性”的方式对属性进行赋值。则需要将属性声明为私有的(private)。此时针对于属性就体现了封装性。
二、封装性的体现:
我们将类的属性私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值。
拓展:不对外暴露的私有的方法;单例模式…
三、封装性的体现,需要权限修饰符来配合
1、Java规定的4种权限(从小到大):private、缺省、protected、public
2、4种权限可以用来修饰类及类的内部结构:属性、方法、构造器、内部类
修饰类的话:只能使用:缺省、public
**封装性总结:**Java提供了4种权限修饰符来修饰类及类的内部结构,体现类及类的内部结构在被调用时的可见性的大小。
9、构造器
一、构造器的作用
1、创建对象:new + 构造器
2、初始化对象的信息
说明:
1、如果没有显示的定义类的构造器的话,则系统默认提供一个空参的构造器。
2、定义构造器的格式:权限修饰符 类名(形参列表){ }
3、一个类中定义的多个构造器,彼此也构成重载。
4、一但我们显示的定义了类的构造器之后,系统就不在提供默认的空参构造器。
5、一个类中,至少会有一个构造器。
10、关键字的使用
- this关键字的使用
1.this可以用来修饰:属性、方法、构造器
2.this修饰属性和方法:
this理解为:当前对象
在类的方法中,我们可以使用“this.属性”或“this.方法”的方式,调用当前对象属性或方法。但是,通常情况下,我们都选择省略“this.”。特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用“this.变量”的方式,表明此变量是属性,而非形参。
在类的构造器中,我们可以使用“this.属性”或“this.方法”的方式,调用当前正在创建的对象属性或方法。但是,通常情况下,我们都选择省略“this.”。特殊情况下,如果构造器的形参和类的属性同名时,我们必须显式的使用“this.变量”的方式,表明此变量是属性,而非形参。
3.this调用构造器
①我们在类的构造器中,可以显式的使用“this(形参列表)”方式,调用本类中指定的其他构造器。
②构造器中不能通过“this(形参列表)”方式调用自己。
③如果一个类中有n个构造器,则最多有n - 1个构造器中使用了“this(形参列表)”。
④规定:“this(形参列表)”必须声明在当前构造器的首行。
⑤构造器内部,最多只能声明一个“this(形参列表)”,用来调用其他的构造器。
- package关键字的使用
1.为了更好的实现项目中类的管理,提供包的概念。
2.使用package声明类或接口所属的包,声明在源文件的首行。
3.包,属于标识符,遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”。
4.包名每 “ . ” 一次,就代表一层文件目录。
补充:同一个包下,不能命名同名的接口、类。不同的包下,可以命名同名的接口、类。