面向对象入门(类和对象)
今日内容
- 面向对象编程思想
- 类的定义 --------------------------------->重点
- 对象的创建和使用 -------------------->重点
- 对象的内存图 -------------------->理解
- 成员变量和局部变量的区别
- 封装-------------------->重点
- private关键字
- set\get方法
- this关键字
- 构造方法 -------------------->重点
- API
教学目标
- 能够知道类和对象的关系
- 能够完成类的定义及使用
- 能够知道对象在内存中的初始化过程
- 能够知道局部变量和成员变量的区别
- 能够知道private关键字的特点
- 能够知道this关键字的作用
- 能够知道构造方法的格式和注意事项
- 能够完成一个标准类代码的编写及测试
- 能够知道帮助文档的使用步骤
知识点1-类和对象
知识点–1. 面向对象和面向过程编程思想
目标
- 理解面向过程和面向对象编程思想
路径
- 面向过程编程思想
- 面向对象编程思想
- 举例对比2种编程思想
讲解
编程思想其实就是编程思路,我们开发中2种经典的编程思想就是面向过程编程思想和面向对象编程思想.
面向过程编程思想
- 强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现
面向对象编程思想
- 强调的是对象, 通过调用对象的行为来实现功能,而不是自己一步一步的去操作实现。
举例对比2种编程思想
-
洗衣服:
- 面向过程:把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
- 面向对象: 把衣服脱下来–>给女朋友去洗
-
吃饭
- 面向过程: 买菜—>洗菜—>炒菜—>吃
- 面向对象: 找个饭店–>10块钱
-
java程序: 需求:打印数组中所有的元素,打印格式为: [元素1,元素2,元素3,元素,…,元素n]
import java.util.Arrays; public class Test { public static void main(String[] args) { // 需求:打印数组中所有的元素,打印格式为: [元素1,元素2,元素3,元素,...,元素n] // 定义一个数组 int[] arr = {10, 20, 30, 40, 50, 60}; // 面向过程:强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现 // 1.打印一个左中括号,不换行 System.out.print("["); // 2.循环遍历数组元素 for (int i = 0; i < arr.length; i++) { // 3.在循环中,判断遍历出来的元素: if (i == arr.length - 1) { // 4.如果遍历出来的元素是最后一个元素,打印格式为: 元素 System.out.print(arr[i]); } else { // 5.如果遍历出来的元素不是最后一个元素,打印格式为: 元素,空格 System.out.print(arr[i]+", "); } } // 6.循环结束后,打印右中括号 System.out.println("]"); System.out.println("===================================================="); // 面向对象:强调的是对象,无须清楚每一个步骤,只需要找到可以完成功能的对象,让该对象去完成即可 // api中jdk提供了一个Arrays类,该类的toString方法可以帮助我们按照这种格式打印数组中的元素 System.out.println(Arrays.toString(arr)); } }
小结
- 面向过程:是一种编程思想
- 面向对象:是一种编程思想
- 区别:
- 面向过程:注重的是步骤,必须清楚每一个步骤,按照步骤一步一步去实现
- 面向对象:注重的是对象,无须清楚每一个步骤,只需要使用对象调用行为来完成需求
知识点–2. 类的概述
目标
- 能够理解什么是类,以及类由什么组成
路径
- 类的概述
- 类的组成
讲解
类的概述
- 类是用来描述一类具有共同属性和行为事物的统称。所以其实类在客观世界里是不存在的,是抽象的,只是用来描述数据信息的。
- 人类: 描述信息
- 手机类: 描述信息
- 学生类: 描述信息
- 狗类: 描述信息
- …
类的组成
- 属性:就是该事物的状态信息。
- 行为:就是该事物能够做什么。
举例
- 手机类
- 属性:品牌、价格…。
- 行为:打电话、发短信…。
小结
- 类是用来描述一群具有共同属性和行为事物的统称,类是抽象的,看不见,摸不着的,用来描述数据信息的
- 类的组成:
- 属性
- 行为
知识点–3. 对象的概述
目标
- 理解什么是对象
路径
- 对象的概念
- 举例
讲解
对象的概念
-
对象是类的一个实例(并不是你的女朋友哈),具体存在的,看得见摸得着的,并且具备该类事物的属性和行为
- 对象的属性:对象的属性具有特定的值
- 对象的行为:对象可以操作的行为
-
人类: 描述信息 抽象
- 李四
- 张三
-
手机类: 描述信息
- 你手上的那台华为手机
-
学生类: 描述信息
- 106期的张三
-
狗类: 描述信息
- 张三家的那条狗
举例
- 对象: 你手上拿的这台手机
- 属性:华为、1999…。 对象的属性具体的值,类中的属性没有具体的值
- 行为:使用打电话功能,使用发短信功能。对象可以使用行为
- 例如:
- 自行车---------->类
- 摩拜单车------->类
- 你早上骑得那辆摩拜单车---->对象
- …
小结
- 对象是类的实例,具体存在的,看得见摸得着的
- 对象的属性是有具体的值
- 对象的行为其实就是可以使用的功能\行为
知识点–4. 类和对象的关系
目标
- 理解类和对象的关系
路径
- 类和对象的关系
讲解
类和对象的关系
-
类是对一类具有共同属性和行为的事物的统称,是抽象的
-
对象是一类事物的具体实例,看得见,摸的着的,真实存在的实体,是具体的
-
类是对象的抽象,对象是类的实体
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nE8YELuC-1606478713825)(img\1584029135069.png)]
小结
- 类是对象的抽象,对象是类的实体
- 类看成是对象的数据类型: (类是用来描述对象)
知识点–5. 类的定义【应用】
目标
- 掌握如何定义一个类
路径
- 回顾类的组成
- 类的定义步骤
- 类的定义格式
- 举例
讲解
复习类的组成
类的组成是由属性和行为两部分组成
- 属性:该类事物的状态信息,在类中通过成员变量来体现(类中方法外的变量)
- 行为:该类事物有什么功能,在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)
类的定义步骤
①定义类
②编写类的成员变量
③编写类的成员方法
类的定义格式
public class 类名 {// 定义一个类
// 类里面:属性(成员变量),行为(成员方法)
// 定义成员变量
数据类型 变量名1;
数据类型 变量名2;
...
// 定义成员方法
方法; 去掉static
}
举例
- 定义一个手机类,类名为(Phone),类的属性有:品牌(brand),价格(price),类的行为:打电话(call),发短信(sendMessage)
public class Phone {
// 属性: 品牌(brand),价格(price)
// 成员变量
String brand;// 品牌
double price;// 价格
// 行为: 打电话(call),发短信(sendMessage)
// 成员方法
/*
明确:
返回值类型: void
参数: String
*/
public void call(String phoneNum){
System.out.println("正在给"+phoneNum+"打电话...");
}
/*
明确:
返回值类型:void
参数: String phoneNum,String message
*/
public void sendMessage(String phoneNum,String message){
System.out.println("正在给"+phoneNum+"发短信,短信的内容是:"+message);
}
}
小结
-
定义类的格式
public class 类名 {// 定义一个类 // 类里面:属性(成员变量),行为(成员方法) // 定义成员变量 数据类型 变量名1; 数据类型 变量名2; ... // 定义成员方法 方法; 去掉static }
知识点–6. 对象的创建和使用
目标
- 掌握对象的创建和对象的使用
路径
- 对象的创建
- 对象的使用
- 案例演示
讲解
对象的创建
- 创建对象的格式:
类名 对象名 = new 类名();
- 类其实就是对象的数据类型,类是引用数据类型
- 例: Phone p1 = new Phone (); 创建了一个手机对象(Phone类的对象)
对象的使用
- 调用成员的格式:
- 访问成员变量
- 获取成员变量的值: 对象名.成员变量名
- 给成员变量赋值: 对象名.成员变量名=值;
- 访问成员方法
- 对象名.成员方法();
- 访问成员变量
案例演示
public class Phone {
// 属性: 品牌(brand),价格(price)
// 成员变量
String brand;// 品牌
double price;// 价格
// 行为: 打电话(call),发短信(sendMessage)
// 成员方法
/*
明确:
返回值类型: void
参数: String
*/
public void call(String phoneNum){
System.out.println("正在给"+phoneNum+"打电话...");
}
/*
明确:
返回值类型:void
参数: String phoneNum,String message
*/
public void sendMessage(String phoneNum,String message){
System.out.println("正在给"+phoneNum+"发短信,短信的内容是:"+message);
}
}
package com.itheima.demo3_对象的创建和使用;
public class Test {
public static void main(String[] args) {
/*
对象的创建(重点):
格式: 类名 对象名 = new 类名();
对象的使用:
访问成员变量: 对象名.成员变量名
访问成员方法(重点):
无返回值的方法: 对象名.方法名(实参); ------>直接调用
有返回值的方法:
对象名.方法名(实参); ------>直接调用
数据类型 变量名 = 对象名.方法名(实参); ------>赋值调用 开发中
System.out.println(对象名.方法名(实参));---->输出调用 讲课中
成员变量有默认值:
整数类型: 默认值是0
小数类型: 默认值是0.0
布尔类型: 默认值是false
字符类型: 默认值是不可见字符
引用类型: 默认值是null
*/
// 创建手机对象
Phone p1 = new Phone();
// 使用对象
// 访问成员变量:
System.out.println(p1.brand);// null
System.out.println(p1.price);// 0.0
// 给成员变量赋值
p1.brand = "华为";
p1.price = 2999.9;
// 取值
System.out.println(p1.brand);// 华为
System.out.println(p1.price);// 2999.9
System.out.println("=========================");
// 访问成员方法:
p1.call("10086");
p1.sendMessage("10086","请问联通的客服电话号码是多少?");
}
}
小结
对象的创建(重点):
格式: 类名 对象名 = new 类名();
对象的使用:
访问成员变量: 对象名.成员变量名
访问成员方法(重点):
无返回值的方法: 对象名.方法名(实参); ------>直接调用
有返回值的方法:
对象名.方法名(实参); ------>直接调用
数据类型 变量名 = 对象名.方法名(实参); ------>赋值调用 开发中
System.out.println(对象名.方法名(实参));---->输出调用 讲课中
成员变量有默认值:
整数类型: 默认值是0
小数类型: 默认值是0.0
布尔类型: 默认值是false
字符类型: 默认值是不可见字符
引用类型: 默认值是null
实操–7. 学生对象-练习
需求
- 首先定义一个学生类,然后定义一个学生测试类,在学生测试类中通过对象完成成员变量和成员方法的使用
分析
- 定义学生类
- 成员变量:姓名,年龄…
- 成员方法:学习,做作业…
- 测试类
- 创建main方法,在main 方法中创建学生对象
- 使用学生对象访问成员变量和访问成员方法
实现
public class Student {
// 成员变量: 姓名,年龄...
String name;// 姓名
int age;// 年龄
// 成员方法: 学习,做作业...
public void study(){
System.out.println("学生正在学习Java...");
}
public void doHomeWork(){
System.out.println("学生正在做作业...");
}
}
public class Test {
public static void main(String[] args) {
// 需求:首先定义一个学生类,然后定义一个学生测试类,在学生测试类中通过对象完成成员变量和成员方法的使用
// 创建学生对象
Student stu = new Student();
// 使用对象访问成员变量
stu.name = "冰冰";
stu.age = 18;
System.out.println(stu.name);// 冰冰
System.out.println(stu.age);// 18
// 使用对象访问成员方法
stu.study();
stu.doHomeWork();
}
}
小结
略
知识点–8. 单个对象内存图
目标
- 掌握单个对象的内存图
路径
- 查看程序案例
- 绘制内存图
讲解
查看程序案例
代码
public class Student {
// 成员变量: 姓名,年龄...
String name;// 姓名
int age;// 年龄
// 成员方法: 学习,做作业...
public void study(){
System.out.println("学生正在学习Java...");
}
public void doHomeWork(){
System.out.println("学生正在做作业...");
}
}
public class Test {
public static void main(String[] args) {
// 创建Student对象
Student stu = new Student();
// 使用对象访问成员变量
stu.name = "冰冰";
stu.age = 18;
System.out.println(stu.name);// 冰冰
System.out.println(stu.age);// 18
// 使用对象访问成员方法
stu.study();
stu.doHomeWork();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NLUx92P5-1606478713828)(img\image-20201024123601601.png)]
小结
- 只要创建对象,就会在堆区开辟一块空间
- 只要调用方法,就会在栈区开辟一块空间,用来执行该方法
知识点–9. 多个对象内存图【理解】
目标
- 掌握多个对象的内存图
路径
- 查看程序案例
- 绘制内存图
讲解
查看程序案例
public class Test {
public static void main(String[] args) {
// 创建Student对象
Student stu1 = new Student();
stu1.name = "冰冰";
stu1.age = 18;
System.out.println(stu1.name);// 冰冰
System.out.println(stu1.age);// 18
System.out.println("==========================");
// 创建Student对象
Student stu2 = new Student();
stu2.name = "热巴";
stu2.age = 17;
System.out.println(stu2.name);// 热巴
System.out.println(stu2.age);// 17
}
}
绘制内存图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S8JPeJFt-1606478713829)(img\image-20201024123642694.png)]
小结
- 多个对象在堆内存中,都有不同的内存划分,成员变量存储在各自的内存区域中,成员方法多个对象共用的一份
- 凡是new就会重新在堆区开辟一块新空间
- 对象和对象之间的关系是相互独立的
知识点–10. 多个变量指向相同对象内存图【理解】
目标
- 掌握多个变量指向相同对象内存图
路径
- 查看程序案例
- 绘制内存图
讲解
查看程序案例
public class Test {
public static void main(String[] args) {
// 创建Student对象
Student stu1 = new Student();
// 给属性赋值
stu1.name = "冰冰";
stu1.age = 18;
System.out.println(stu1.name);// 冰冰
System.out.println(stu1.age);// 18
// 把stu1赋值给stu2
Student stu2 = stu1;
stu2.name = "热巴";
System.out.println(stu1.name);// 热巴
System.out.println(stu2.name);// 热巴
}
}
绘制内存图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BTB5CQov-1606478713831)(img\image-20201024123717846.png)]
小结
- 当多个对象的引用指向同一个内存空间(变量所记录的地址值是一样的)
- 只要有任何一个对象修改了内存中的数据,随后,无论使用哪一个对象进行数据获取,都是修改后的数据。
知识点–11. 成员变量和局部变量的区别【理解】
目标
- 理解成员变量和局部变量的区别
路径
- 成员变量和局部变量的区别
讲解
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uKhUz7qE-1606478713832)(img\1582716017361.png)]
- 类中位置不同:成员变量(类中方法外)局部变量(方法内部或方法声明上)
- 内存中位置不同:成员变量(堆内存)局部变量(栈内存)
- 生命周期不同:成员变量(随着对象的存在而存在,随着对象的消失而消失)局部变量(随着方法的调用而存在,随着方法的调用完毕而消失)
- 初始化值不同:成员变量(有默认初始化值)局部变量(没有默认初始化值,必须先定义,赋值才能使用)
public class Car {
String color;// 颜色 成员变量 默认值null
public void drive(){
int speed = 150;// 速度 局部变量
System.out.println(speed);
}
}
public class Test {
/*
成员变量和局部变量的区别:
定义的位置不同: 成员变量定义在类中方法外,局部变量定义在方法中
在内存中的位置不同: 成员变量是在堆区,局部变量是在栈区
生命周期不同:
成员变量是随着对象的创建而存在,随着对象的销毁而销毁
局部变量是随着方法的调用而存在,随着方法调用完毕而销毁
默认值不同:
成员变量有默认值
局部变量没有默认值,不赋值不能直接使用
*/
public static void main(String[] args) {
Car car = new Car();
System.out.println(car.color);
car.drive();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9bR28c8D-1606478713833)(img\5_成员变量和局部变量的区别.png)]
小结
位置不同: 成员变量定义在类中方法外,局部变量定义在方法中
在内存中的位置不同: 成员变量在堆区,局部变量在栈区
生命周期不同:
成员变量是随着对象的存在而存在,随着对象的销毁而销毁
局部变量是随着方法的调用而存在,随着方法的执行完毕而销毁
默认值不同:
成员变量用默认值,局部变量没有默认值
知识点–2. 封装
知识点–2.1 private关键字
目标
- 理解private关键字的含义和使用格式
路径
- private的含义
- private的使用格式
- 案例
讲解
private的含义
- 概述: private是一个权限修饰符,代表最小权限。
- 特点:
- 可以修饰成员变量和成员方法。
- 被private修饰后的成员变量和成员方法,只在本类中才能访问。
private的使用格式
// private关键字修饰成员变量
private 数据类型 变量名 ;
// private关键字修饰成员方法
private 返回值类型 方法名(参数列表){
代码
}
案例
public class Student {
// 成员变量: 姓名,年龄...
String name;// 姓名
private int age;// 年龄
// 成员方法: 学习,做作业...
public void study(){
System.out.println("学生正在学习Java...");
}
private void doHomeWork(){
System.out.println("学生正在做作业...");
}
}
public class Test {
public static void main(String[] args) {
/*
- private的含义:
概述:private是一个权限修饰符关键字,表示最小权限
- private的使用格式:
修饰成员变量: private 数据类型 变量名;
修饰成员方法: private 返回值类型 方法名(形参){ 方法体 }
- private特点:
1.可以修饰成员变量和成员方法
2.被private修饰符的成员变量和成员方法只能在本类中直接访问
*/
// 创建Student对象
Student stu = new Student();
// 访问成员变量
stu.name = "冰冰";
// 编译报错,因为age成员变量被private修饰,只能在Student类中直接访问
// stu.age = 18;
// 访问成员方法
stu.study();
// 编译报错,因为doHomeWork方法被private修饰,只能在Student类中直接访问
// stu.doHomeWork();
}
}
小结
- private的含义: private是一个权限修饰符,表示最小的权限
- private的使用: 修饰成员变量和成员方法
修饰成员变量的格式: private 数据类型 变量名;
修饰成员方法的格式: private 返回值类型 方法名(参数列表){...}
- 特点: 被private修饰的成员变量或者成员方法,只能在本类中访问
知识点–2.2 对属性封装的步骤
目标
- 理解对属性封装的步骤
路径
- 为什么要对属性进行封装
- 对属性封装的步骤
讲解
为什么要对属性进行封装
public class Student {
// 成员变量
String name;// 姓名
int age;// 年龄
}
public class Test {
public static void main(String[] args) {
// 创建对象
Student stu = new Student();
// 给属性赋值
stu.name = "冰冰";
// 通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患
// 怎么解决?----->解决办法: 对类中的属性进行封装(隐藏),让外界不能直接通过对象名访问
stu.age = -18;// 数据是不合法的
System.out.println(stu.name);// 冰冰
System.out.println(stu.age);// -18
}
}
- 通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患,应该怎么解决呢?
- 解决方式: 不让外界直接访问成员变量(也就是要对属性进行封装)
对属性封装的步骤
-
使用private修饰成员变量
public class Student { // 成员变量 private String name;// 姓名 private int age;// 年龄 }
-
对需要访问的成员变量,提供对应的
getXxx
方法(获取属性的值) 、setXxx
方法(给属性赋值)。
小结
- 略
知识点–2.3 set和get方法
目标
- 掌握set和get方法的书写
路径
- set和get方法的介绍
- set和get方法的书写
讲解
set和get方法的介绍
-
由于属性使用了private关键字修饰,在其他类中无法直接访问,所以得提供公共的访问方法,我们把这张方法叫做set和get方法
- get方法: 提供“get变量名()”方法,用于获取成员变量的值,方法用public修饰
- set方法: 提供“set变量名(参数)”方法,用于设置成员变量的值,方法用public修饰
set和get方法的书写
public class Student {
// 成员变量
private String name;// 姓名
private int age;// 年龄
// 成员方法
public void setName(String n){
name = n;
}
public void setAge(int a){
if (a < 0 || a > 150){
age = 0;
}else{
age = a;
}
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
public class Test {
public static void main(String[] args) {
/*
为什么对属性进行封装:
通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患
对属性进行封装:
1.使用private关键字修饰成员变量(属性)
2.提供公共的成员方法用来给属性赋值和取值(set\get方法方法)
*/
// 创建对象
Student stu = new Student();
// 给属性赋值
stu.setName("冰冰");
stu.setAge(-18);
// 取值
System.out.println(stu.getName());// 冰冰
System.out.println(stu.getAge());// 0
/*stu.name = "冰冰";
// 通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患
// 怎么解决?----->解决办法: 对类中的属性进行封装(隐藏),让外界不能直接通过对象名访问
stu.age = -18;// 数据是不合法的
System.out.println(stu.name);
System.out.println(stu.age);*/
}
}
小结
知识点–2.4 this关键字
目标
- 理解this关键字的含义和使用
路径
- 问题
- this关键字的含义和使用
讲解
问题
我们发现 setXxx
方法中的形参名字并不符合见名知意的规定,那么如果修改与成员变量名一致,是否就见名知意了呢?代码如下:
public class Student {
private String name;
private int age;
public void setName(String name) {
name = name;
}
public void setAge(int age) {
age = age;
}
}
经过修改和测试,我们发现新的问题,成员变量赋值失败了。也就是说,在修改了setXxx()
的形参变量名后,方法并没有给成员变量赋值!这是由于形参变量名与成员变量名重名,导致成员变量名被隐藏,方法中的变量名,无法访问到成员变量,从而赋值失败。所以,我们只能使用this关键字,来解决这个重名问题。
this的含义和使用
-
this含义: this代表当前调用方法的引用,哪个对象调用this所在的方法,this就代表哪一个对象
-
this关键字其主要作用是区分同名的局部变量和成员变量
- 方法的形参如果与成员变量同名,不带this修饰的变量指的是形参,而不是成员变量
- 方法的形参没有与成员变量同名,不带this修饰的变量指的是成员变量
-
this的使用格式:
this.成员变量名
-
使用
this
修饰方法中的变量,解决成员变量被隐藏的问题,代码如下:public class Student { private String name; private int age; public void setName(String name) { //name = name; this.name = name; } public String getName() { return name; } public void setAge(int age) { //age = age; this.age = age; } public int getAge() { return age; } }
小贴士:方法中只有一个变量名时,默认也是使用
this
修饰,可以省略不写。
小结
this关键字:
1.作用: 用来区分同名的成员变量和局部变量
2.格式: this.成员变量名
3.this含义:代表当前对象
当前对象: 谁调用this所在的方法,谁就是当前对象
知识点–2.5 this内存原理
目标
- 加深对this的理解
路径
- 查看案例代码
- 绘制内存图
讲解
代码
public class Student {
// 成员变量
private String name;// 姓名
private int age;// 年龄
// 成员方法
public void setName(String name){
this.name = name;
}
// 批量修改变量名: shift+f6+fn
public void setAge(int age){
if (age < 0 || age > 150){
this.age = 0;
}else{
this.age = age;
}
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public void show(){
System.out.println(name+","+age);
}
}
public class Test {
public static void main(String[] args) {
// 创建Student对象
Student stu1 = new Student();
// 赋值
stu1.setName("冰冰");
stu1.setAge(18);
// 调用show方法
stu1.show();// 冰冰,18
System.out.println("=========================");
// 创建Student对象
Student stu2 = new Student();
// 赋值
stu2.setName("热巴");
stu2.setAge(16);
// 调用show方法
stu2.show();// 热巴,16
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uL19oKS9-1606478713834)(img\image-20201024123421373.png)]
小结
略
知识点–2.6 封装概述
目标:
- 理解封装的概念
路径:
- 封装概述
讲解:
封装概述
- 是面向对象三大特征之一(封装,继承,多态)
- 是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作的
封装原则
- 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
- 例如:成员变量使用private修饰,提供对应的getXxx()/setXxx()方法
封装好处
- 通过方法来控制成员变量的操作,提高了代码的安全性
- 把代码用方法进行封装,提高了代码的复用性
小结
略
知识点–3. 构造方法
知识点–3.1 构造方法概述
目标
- 能够理解构造方法的作用和能够定义构造方法
路径
- 构造方法的概述
- 构造方法的定义
讲解
构造方法的概述
- 构造方法是一种特殊的方法,主要是完成对象的创建和对象数据的初始化
构造方法的定义
-
格式
// 空参构造方法 修饰符 类名(){ } // 有参构造方法 修饰符 类名(参数列表){ // 方法体 }
-
特点:
- 构造方法的写法上,方法名与它所在的类名相同
- 构造方法没有返回值,所以不需要返回值类型,甚至不需要void
-
示例代码:
public class Student {
// 成员变量: 姓名,年龄
String name;// 姓名
int age; // 年龄
// 空参构造
public Student(){
System.out.println("空参构造");
}
// 有参构造
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void show(){
System.out.println(name+","+age);
}
}
public class Test {
public static void main(String[] args) {
/*
- 构造方法的概述
概述:构造是一种比较特殊的方法
作用:主要用来创建对象,并给对象的属性初始化
特点:
1.构造方法没有返回值,连void都不能写
2.构造方法的方法名必须和类名一致
3.通过new来调用构造方法
- 构造方法的定义:
空参构造:
public 类名(){
}
有参构造:
public 类名(形参){
给属性赋值
}
*/
// 通过调用空参构造方法,创建Student对象
Student stu1 = new Student();
stu1.show();// null,0
// 通过有参构造方法,创建Student对象
Student stu2 = new Student("热巴",18);
stu2.show();// 热巴,18
}
}
小结
构造方法的概述
- 构造方法是一种特殊的方法,主要是完成对象的创建和给对象的属性进行初始化
构造方法的定义
- 格式:
空参构造方法
修饰符 类名(){
}
有参构造方法
修饰符 类名(参数){
方法体(给属性赋值)
}
- 特点:
1.构造方法的方法名和类名一致
2.构造没有返回值,连void都没有
调用构造方法: 通过new来调用
知识点–3.2 构造方法的注意事项
目标
- 理解构造方法的注意事项,并以后开发中知道如何避免
路径
- 构造方法的注意事项
讲解
-
构造方法的创建
- 如果没有定义构造方法,系统将给出一个默认的无参数构造方法
- 如果定义了构造方法,系统将不再提供默认的构造方法
-
构造方法可以重载,既可以定义参数,也可以不定义参数。
-
示例代码
public class Student {
private String name;// 姓名
private int age;// 年龄
// 构造方法
// 空参构造方法
public Student(){
}
// 满参构造方法
public Student(String name,int age){
this.name = name;
this.age = age;
}
// 有参构造方法
public Student(String name){
this.name = name;
}
public Student(int age){
this.age = age;
}
// set\get方法
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
public class Test {
public static void main(String[] args) {
/*
构造方法的注意事项:
1.定义构造方法,方法名一定要和类名一致
2.定义构造方法,一定没有返回值类型,连void都不能写
3.如果一个类没有定义构造方法,系统会默认生成一个空参构造方法
4.如果一个类定义了构造方法,系统就不会默认生成一个空参构造方法
5.构造方法是可以重载的
6.构造方法只能给属性赋值一次,而set方法可以反复给属性赋值
*/
// 通过调用空参构造方法,创建Student对象
Student stu = new Student();
stu.setName("冰冰");
stu.setAge(18);
System.out.println(stu.getName()+","+stu.getAge());// 冰冰,18
// 通过调用满参构造方法,创建Student对象
Student stu2 = new Student("热巴",17);
System.out.println(stu2.getName()+","+stu2.getAge());// 热巴,17
}
}
小结
构造方法的注意事项:
- 构造方法的创建
- 如果没有定义构造方法,系统将给出一个默认的无参数构造方法
- 如果定义了构造方法,系统将不再提供默认的构造方法
- 构造方法可以重载,既可以定义参数,也可以不定义参数。
- 定义构造方法的时候,不要写返回值,连void都不能有
- 定义构造方法的时候,构造方法名和类名一定要一致
知识点–3.3 标准类制作
目标
- 掌握标准类的制作
路径
- 标准类的组成
- 案例演示
讲解
标准类的组成
JavaBean
是 Java语言编写类的一种标准规范。符合JavaBean
的类,要求类必须是公共的,属性使用private修饰,并且具有无参数的构造方法,提供用来操作成员变量的set
和get
方法。
public class ClassName{
//成员变量 private
//构造方法
//无参构造方法【必须】
//满参构造方法【建议】
//getXxx()
//setXxx()
//成员方法
}
案例演示
- 需求:定义标准学生类,要求分别使用空参和有参构造方法创建对象,空参创建的对象通过setXxx赋值,有参创建的对象直接赋值,并通过show方法展示数据。
- 示例代码:
public class Student {
// 成员变量--->private
private String name;// 姓名
private int age;// 年龄
// 空参构造--->快捷键: alt+insert--->Constructor
public Student() {
}
// 满参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// set\get方法--->快捷键: alt+insert--->Getter and Setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// 成员方法
public void show(){
System.out.println("姓名是:"+name+",年龄是:"+age);
}
}
小结
略
知识点–4. API
目标
- 了解API的概念和使用步骤
路径
- API的概念
- API的使用步骤
- 演示API的使用
讲解
API的概念
-
什么是API
API (Application Programming Interface) :应用程序编程接口。Java API是一本程序员的
字典
,是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来,我们不需要关心这些类是如何实现的,只需要学习这些类如何使用即可。所以我们可以通过查询API的方式,来学习Java提供的类,并得知如何使用它们。- API其实就是jdk中核心类库的说明文档
- 对于jdk中的核心类库只需要知道如何使用,无须关心他是如何实现的
API的使用步骤
- 打开API帮助文档。
- 点击显示,找到索引,看到输入框。
- 你要找谁?在输入框里输入,然后回车。
- 看包。java.lang下的类不需要导包,其他需要。
- 看类的解释和说明。
- 看构造方法。
- 看成员方法。
演示API的使用
- 打开帮助文档
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z1xksJR5-1606478713835)(img/01.png)]
-
找到索引选项卡中的输入框
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OomIEWbK-1606478713836)(img/02.png)]
-
在输入框中输入Random
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ImHPnOwv-1606478713837)(img/03.png)]
- 看类在哪个包下
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i9I0ICXo-1606478713837)(img/04.png)]
- 看类的描述
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bd5FllIL-1606478713838)(img/05.png)]
- 看构造方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eeUrSEbJ-1606478713838)(img/06.png)]
- 看成员方法
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e14ydWVm-1606478713839)(img/07.png)]
public class Test {
public static void main(String[] args) {
/*
api的使用步骤:
1.打开api文档
2.点击显示
3.点击索引,在输入框中输入要查找的内容
4.查看包 在java.lang包下的类不需要导包,其余都需要导包
5.查看类的解释说明
6.查看构造方法
7.查看成员方法
eg: 学习jdk中的Scanner类
1.查看包: 在java.util包下,所以需要导包
2.查看类的解释说明: Scanner类是一个简单的文本扫描器,可以用来扫描基本类型和字符串类型的数据
3.查看构造方法:
Scanner(InputStream source)
4.查看成员方法:
int nextInt(); 扫描输入的整数
double nextDouble(); 扫描输入的小数
String next(); 扫描输入的字符串 不能扫描空格,tab,回车...字符
String nextLine(); 扫描输入的字符串(整行字符串) 能扫描空格,tab,回车...字符
*/
// 创建Scanner对象
Scanner sc = new Scanner(System.in);
// 扫描输入的小数
System.out.println("请输入一个小数:");
double num = sc.nextDouble();
System.out.println("num:"+num);
// 特殊情况:
/* System.out.println("请输入您的年龄:");
int age = sc.nextInt();
System.out.println("请输入您的姓名:");
//sc.nextLine();
//String name = sc.nextLine();
String name = sc.next();
System.out.println("姓名name:"+name);
System.out.println("年龄age:"+age);*/
// 扫描输入的字符串
/*System.out.println("请输入一个字符串:");
String str1 = sc.nextLine();
System.out.println("str1:"+str1);*/
// 扫描输入的字符串
/*System.out.println("请输入一个字符串:");
String str1 = sc.next();
System.out.println("str1:"+str1);*/
// 扫描输入的整数
/*System.out.println("请输入一个整数:");
int num = sc.nextInt();
System.out.println("num:"+num);*/
}
}
小结
略
总结
- 能够知道类和对象的关系
类是对象的抽象,对象是类的实例
类是对象的数据类型,对象是根据类来创建的,类中有什么对象就有什么
- 能够完成类的定义及使用
public class 类名{
成员变量: 数据类型 变量名;
成员方法: public 返回值类型 方法名(形参列表){ 方法体 }
}
对象的创建
类名 对象名 = new 类名(实参);
对象的使用
访问成员变量: 对象名.成员变量名
访问成员方法:
无返回值的方法: 对象名.成员方法名(实参);
有返回值的方法:
对象名.成员方法名(实参);
数据类型 变量名 = 对象名.成员方法名(实参);
System.out.println(对象名.成员方法名(实参));
- 能够知道对象在内存中的初始化过程
见课堂上绘制的内存图
- 能够知道局部变量和成员变量的区别
定义的位置不同: 成员变量定义在类中方法外,局部变量定义在方法中
在内存中的位置不同: 成员变量在堆区,局部变量在栈区
生命周期不同:
成员变量随着对象的存在而存在,随着对象的销毁而销毁
局部变量随着方法的调用而存在,随着方法的结束而销毁
默认值不同:
成员变量有默认值,局部变量没有默认值(不赋值不能使用)
- 能够知道private关键字的特点
可以修饰成员变量和成员方法,被private修饰的成员变量和成员方法只能在本类中直接访问
- 能够知道this关键字的作用
用来区分同名的成员变量和局部变量
- 能够知道构造方法的格式和注意事项
空参构造:
修饰符 类名(){}
有参构造:
修饰符 类名(形参){给属性赋值}
注意事项:
1.构造方法没有返回值类型,连void都不能写
2.构造方法名和类名必须一致
3.如果类没有定义构造方法,系统就会为该类自动生成一个空参构造方法
4.如果类中定义了构造方法,系统就不会为该类自动生成一个空参构造方法
5.构造方法可以重载
6.构造方法通过new来调用
- 能够完成一个标准类代码的编写及测试
public class 类名{
成员变量--必须使用private修饰
空参构造
满参构造(建议)
set\get方法
成员方法
}
- 能够知道帮助文档的使用步骤
1.打开api文档
2.点击显示
3.点击索引,在输入框中输入要查找的内容
4.查看包
5.查看类的解释说明
6.查看类的构造方法
7.查看类的成员方法
// 扫描输入的字符串
/System.out.println(“请输入一个字符串:”);
String str1 = sc.next();
System.out.println(“str1:”+str1);/
// 扫描输入的整数
/*System.out.println("请输入一个整数:");
int num = sc.nextInt();
System.out.println("num:"+num);*/
}
}
#### 小结
略
## 总结
```java
- 能够知道类和对象的关系
类是对象的抽象,对象是类的实例
类是对象的数据类型,对象是根据类来创建的,类中有什么对象就有什么
- 能够完成类的定义及使用
public class 类名{
成员变量: 数据类型 变量名;
成员方法: public 返回值类型 方法名(形参列表){ 方法体 }
}
对象的创建
类名 对象名 = new 类名(实参);
对象的使用
访问成员变量: 对象名.成员变量名
访问成员方法:
无返回值的方法: 对象名.成员方法名(实参);
有返回值的方法:
对象名.成员方法名(实参);
数据类型 变量名 = 对象名.成员方法名(实参);
System.out.println(对象名.成员方法名(实参));
- 能够知道对象在内存中的初始化过程
见课堂上绘制的内存图
- 能够知道局部变量和成员变量的区别
定义的位置不同: 成员变量定义在类中方法外,局部变量定义在方法中
在内存中的位置不同: 成员变量在堆区,局部变量在栈区
生命周期不同:
成员变量随着对象的存在而存在,随着对象的销毁而销毁
局部变量随着方法的调用而存在,随着方法的结束而销毁
默认值不同:
成员变量有默认值,局部变量没有默认值(不赋值不能使用)
- 能够知道private关键字的特点
可以修饰成员变量和成员方法,被private修饰的成员变量和成员方法只能在本类中直接访问
- 能够知道this关键字的作用
用来区分同名的成员变量和局部变量
- 能够知道构造方法的格式和注意事项
空参构造:
修饰符 类名(){}
有参构造:
修饰符 类名(形参){给属性赋值}
注意事项:
1.构造方法没有返回值类型,连void都不能写
2.构造方法名和类名必须一致
3.如果类没有定义构造方法,系统就会为该类自动生成一个空参构造方法
4.如果类中定义了构造方法,系统就不会为该类自动生成一个空参构造方法
5.构造方法可以重载
6.构造方法通过new来调用
- 能够完成一个标准类代码的编写及测试
public class 类名{
成员变量--必须使用private修饰
空参构造
满参构造(建议)
set\get方法
成员方法
}
- 能够知道帮助文档的使用步骤
1.打开api文档
2.点击显示
3.点击索引,在输入框中输入要查找的内容
4.查看包
5.查看类的解释说明
6.查看类的构造方法
7.查看类的成员方法