类的定义格式
public class ClassName {
//成员变量
//成员方法
}
-
定义类：就是定义类的成员，包括成员变量和成员方法。
-
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。
-
成员方法：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细讲解。
类的定义格式举例：
public class Student {
//成员变量
String name；//姓名
int age；//年龄
//成员方法
//学习的方法
publicvoid study() {
System.out.println("好好学习，天天向上");
}
//吃饭的方法
publicvoid eat() {
System.out.println("学习饿了要吃饭");
}
}
1.4 对象的使用
对象的使用格式
创建对象：
类名 对象名 = new 类名();
使用对象访问类中的成员:
对象名.成员变量； 对象名.成员方法()；
成员变量的默认值
| 数据类型 | 默认值 | |
|---|---|---|
| 基本类型 | 整数（byte，short，int，long） | 0 |
| 浮点数（float，double） | 0.0 | |
| 字符（char） | '\u0000' | |
| 布尔（boolean） | false | |
| 引用类型 | 数组，类，接口 | null |
两个对象，调用同一方法内存图
对象调用方法时，根据对象中方法标记（地址值），去类中寻找方法信息。这样哪怕是多个对象，方法信息只保存一份，节约内存空间。
1.7 成员变量和局部变量区别
变量根据定义位置的不同，我们给变量起了不同的名字。如下图所示：
-
在类中的位置不同
重点-
成员变量：类中，方法外
-
局部变量：方法中或者方法声明上(形式参数)
-
-
作用范围不一样
重点-
成员变量：类中
-
局部变量：方法中
-
-
初始化值的不同
重点-
成员变量：有默认值
-
局部变量：没有默认值。必须先定义，赋值，最后使用
-
-
在内存中的位置不同
了解-
成员变量：堆内存
-
局部变量：栈内存
-
-
生命周期不同
了解-
成员变量：随着对象的创建而存在，随着对象的消失而消失
-
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
局部变量和成员变量的区别 1.在类中的位置不同【重点】 成员变量：类中，方法外 局部变量：方法中或者方法声明上(形式参数) 2.在内存中的位置不同（了解） 成员变量：堆内存 局部变量：栈内存 3.生命周期不同（了解） 成员变量：随着对象的创建而存在，随着对象的消失而消失 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 4.初始化值的不同【重点】 成员变量：有默认值 局部变量：没有默认值。必须先定义，赋值，最后使用 5.作用范围不一样【重点】 成员变量：类中 局部变量：方法中 -
第2章 封装
2.1 封装概述
概述
面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
原则
将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。
2.2 封装的步骤
-
使用
private关键字来修饰成员变量。 -
对需要访问的成员变量，提供对应的一对
getXxx方法 、setXxx方法。
2.3 封装的操作——private关键字
private的含义
-
private是一个权限修饰符，代表最小权限。
-
可以修饰成员变量和成员方法。
-
被private修饰后的成员变量和成员方法，只在本类中才能访问。
private的使用格式
private 数据类型 变量名 ；
我们只能使用this关键字，来解决这个重名问题。
this的含义
this代表所在类的当前对象的引用（地址值），即对象自己的引用。
记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。
this使用格式
this.成员变量名；
使用 this 修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：
小贴士：方法中只有一个变量名时，默认也是使用
this修饰，可以省略不写。
2.5 封装优化2——构造方法
当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。
小贴士：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。
构造方法的定义格式
修饰符 构造方法名(参数列表){
// 方法体
}
构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用构造方法后，代码如下：
-
如果你不提供构造方法，系统会给出无参数构造方法。
-
如果你提供了构造方法，系统将不再提供无参数构造方法。
-
构造方法是可以重载的，既可以定义参数，也可以不定义参数。
2.6 标准代码——JavaBean
JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的set 和get 方法。
public class ClassName{
//成员变量
//构造方法
//无参构造方法【必须】
//有参构造方法【建议】
//成员方法
//getXxx()
//setXxx()
}
练习1:
类的定义格式:
修饰符 class 类名 {
//成员变量
//成员方法
}
注意:
1.修饰符目前固定写法就是public
2.class是定义类的关键字
3.类名: class关键字后面的名称叫做类名,
就是一个标识符,注意如果修饰符是public,
那么java文件的名称必须和类名保持一模一样
成员变量:
1.和以前定义变量的格式相同: 数据类型 变量名称
2.成员变量定义在类中方法外
3.以前定义的变量要么在方法内部,要么在方法声明的()中,称为局部变量
成员方法:
1.和以前定义方法的格式相同
2.唯一区别就是必须要去掉static关键字
public 返回值类型 方法名称(形式参数列表...){
功能代码;
}
3.其中参数列表和返回值类型都是根据需求确定的
//空参构造
public Student() { //创建Student类的对象: 空参构造
Student stu = new Student();
}
//满参构造
public Student(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
//创建Student类的对象: 满参构造
Student stu2 = new Student("韩梅梅","女",16);
//2.给所有private修饰的成员变量提供getter和setter方法
public String getName() {
return name;
}
//成员方法
//吃饭
public void eat() {
System.out.println("吃饭饭...");
}
System.out.println(stu.getName());//张三
//调用成员方法
stu.eat();
//测试类
/*
数据类型分成基本类型和引用类型
我们自己定义的类都属于引用类型,使用有固定的三个步骤
1.导包(找到我们要使用的类)
(1)格式: import 包名.类名;
(2)当前类和所使用的类在同一个包中,不需要导包
(3)java.lang中类,不需要导包
(4)快捷键: alt + 回车
2.创建对象
类名 对象名 = new 类名(实际参数...);
(1)类名: class关键字后面指定的名字
(2)对象名: 就是一个标识符,给对象起个名字方便使用
(3)=: 代表赋值,把右侧new出来的对象,保存(地址值)到左侧的变量中
(4)new: JVM创建对象开辟内存空间的过程
(5)(实际参数...): 根据类中定义的格式确定的,目前()中不用写东西
(6)=左右两边的类名要一致
int[] arr = new int[3];
3.对象的使用:
(1)对象名: 保存对象在堆内存空间的地址值,是一个十六进制的int数字
(2)成员变量的使用:
对象名.成员变量名
比如:
stu.name: 表示对象stu的name属性值
stu.gender: 表示对象stu的gender属性值
stu.age: 表示对象stu的gender属性值
(3)成员方法的使用:
对象名.成员方法名称(实际参数...);
比如:
stu.eat(): 表示调用对象stu的eat方法
stu.study(): 表示调用对象stu的study方法
stu.sleep(): 表示调用对象stu的sleep方法
stu.showInfo(): 表示调用对象stu的showInfo方法
点(.)的理解: 什么什么 的 什么什么
4.对象的成员变量有默认值:
整数: 0
小数: 0.0
字符: 空白字符
布尔: false
引用类型: null
//给成员变量赋值
stu.name = "张三";
stu.gender = "男";
stu.age = 18;
注意:
1.创建对象后,成员变量都是默认值
2.对象名保存对象的地址值
3.为了节约内存空间,对象中并没有保存方法本身,而是保存方法的地址值
private关键字的使用
public class Person02 {
//成员变量
String name;//姓名
//成员变量private修饰
private int age;//年龄
//getAge方法: 获取成员变量age的值
public int getAge() {
return age;
}
//setAge方法: 给成员变量age赋值
public void setAge(int a) {
if (a >= 0 && a <= 100) {
age = a;
}
}
//成员方法
public void show() {
System.out.println("姓名: "+name+", 年龄: "+age);
}
}
/*
问题:
定义类,规定了成员变量的含义,但是却无法保证成员变量的取值在一个合理有效的范围
比如: 年龄age取值应该 age>=0 && age<=100
解决方案:
1.将需要保护的成员变量使用private关键字,修饰一把
2.private可以修饰的内容:
(1)修饰成员变量: private 数据类型 变量名称;
(2)修饰成员方法: private 返回值类型 方法名称(参数列表...){...}
3.private关键字的特点:
(1)被private修饰的成员变量,只能在本类中直接使用,
在其它类中不可以通过对象名.成员变量名的形式继续访问了
(2)被private修饰的成员方法,只能在本类中直接使用
在其它类中不可以调用了
4.使用private后暴露了新的问题?
成员变量作用就是用来存/取值的,被private修饰后,在其它类中,
就不能完成成员变量值的存储和获取了
解决方案:
(1)为private修饰的成员变量提供getter方法
getter方法作用: 用来获取成员变量的值的
三要素:
a.方法名称: get+成员变量名(第一个字母大写)
b.是否有未知数据参加运算: 没有 没有参数列表
c.是否有结果数据产生: 有,成员变量的类型
(2)为private修饰的成员变量提供setter方法
setter方法作用: 用来给成员变量的设置值
三要素:
a.方法名称: set+成员变量名(第一个字母大写)
b.是否有未知数据参加运算: 有 定义一个和成员变量类型相同的变量
c.是否有结果数据产生: 没有,void
可以在setter方法内部添加逻辑判断
*/
public class Demo02Person02 {
public static void main(String[] args) {
//创建Person02类的对象
Person02 p = new Person02();
//给成员变量赋值
p.name = "灭绝师太";
//成员变量private修饰,不能使用对象名称直接访问
//p.age = -8848;
//调用set方法给成员变量赋值
p.setAge(-8848);
//调用成员方法
p.show();
}
}
this关键字的使用
/*
方法内部直接写变量名的访问规则
就近原则: 方法内部有,直接使用,方法内部没有,找成员变量
局部变量和成员变量同名时,访问规则?
1.直接写变量名: 代表的是局部变量
2.this.变量名: 代表的是成员变量
this关键字作用:
是用来解决局部变量和成员变量同名的情况
this代表谁呢?
哪个对象调用方法,方法内部的this就代表调用方法的那个对象
简单来讲: 谁来调用我,我就代表谁
注意:
每个方法内部都有一个this关键字,用来接收调用方法的对象的地址值,
如果需要使用this,那么就直接使用,不需要用this,那就算了
*/
public class Person03 {
//成员变量
String name;//姓名
//打招呼
public void sayHello(String who) {
System.out.println("你好: " + who + ", 我是: " + name);
}
/*
以上方法参数who不够见名知意
把参数名称who改成name
问题: 方法内部的局部变量名和类的成员变量名重名了
导致: 方法内部直接写变量名,代表方法内部的局部变量,无法访问到成员变量了
*/
public void sayHello2(String name) {
System.out.println("你好: " + name + ", 我是: " + name);
}
/*
name: 代表方法内部自己的name
this.name: 代表成员变量的name
*/
public void sayHello3(String name) {
System.out.println("...this: "+this);
System.out.println("你好: " + name + ", 我是: " + this.name);
}
}
public class Demo03Person03 {
public static void main(String[] args) {
//创建Person03类的对象
Person03 p = new Person03();
p.name = "张亮";
//调用成员方法
p.sayHello("柳岩");
p.sayHello2("柳岩");
System.out.println("main...p: "+p);
p.sayHello3("柳岩");
p.sayHello("aaa");
}
}
/*
要求:
1.所有成员变量必须使用private修饰
2.给所有private修饰的成员变量提供getter和setter方法
快捷键:
alt + insert --> getter and setter --> 选定成员变量 --> ok
/*
创建对象的过程:
使用new关键字创建对象 + 调用构造方法
构造方法:
1.作用: 当我们使用new关键字创建对象后(成员变量都是默认值),
必须调用构造方法,完成对象成员的初始化工作
2.格式:
修饰符 构造方法名称(参数列表...){
方法体;
return ;//建议省略
}
3.格式解释:
(1)修饰符中没有static关键字,目前就认为是固定public
(2)没有返回值类型,连void都没有
(3)构造方法名称必须和类名保持一模一样
(4)参数列表根据需求确定
(5)方法体: 一般是用来完成成员变量的赋值的
(6)可以写return ;,建议省略
4.注意:
(1)自定义类时,如果一个构造方法都不写,JVM默认隐藏提供一个空参构造
(2)构造方法也是方法,可以重载
(3)自定义类时,只要自己定义一个构造方法,JVM就不再提供空参构造
5.注意:
set方法主要是完成对象的成员变量值的修改
构造方法主要是对象创建后,立刻马上给对象的成员变量初始化的
*/
标准的java类的定义
标准的Java类的定义要求: 1.所有成员变量private修饰 2.为所有private修饰的成员变量提供getter和setter方法 快捷键: alt + insert --> Getter and Setter --> 选择成员变量 --> ok 3.提供空参构造方法(必须提供)和满参构造方法(可选的) 空参构造快捷键: alt + insert --> Constructor --> Select None 满参构造快捷键: alt + insert --> Constructor --> 选择成员变量 --> ok
630
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
