1. 类和对象
1.1 面向对象和面向过程编程思想
编程思想其实就是编程思路,我们开发中2种经典的编程思想就是面向过程编程思想和面向对象编程思想.
面向过程编程思想
- 强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现
面向对象编程思想
- 强调的是对象, 通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。
举例对比2种编程思想
-
洗衣服:
- 面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
- 面向对象: 把衣服脱下来–>给女朋友去洗
-
吃饭
- 面向过程: 买菜—>洗菜—>炒菜—>吃
- 面向对象: 找个饭店–>10块钱
代码演示：
/**
* 需求:打印数组中所有的元素,打印格式为: [元素1，元素2，元素3，元素，...，元素n]
*/
public class test01 {
public static void main(String[] args) {
int[] arr = {10, 20, 30, 40, 50, 60};
//面向过程
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
System.out.print(arr[i]);
} else {
System.out.print(arr[i] + ", ");
}
}
System.out.println("]");
System.out.println("==========================");
// 面向对象
//api中jdk提供了一个Arrays类,该类的toString方法可以帮助我们按照这种格式打印数组中的元素
System.out.println(Arrays.toString(arr));
}
}
小结：
- 面向过程:是一种编程思想
- 面向对象:是一种编程思想
- 区别:
- 面向过程:注重的是步骤,必须清楚每一个步骤,按照步骤一步一步去实现
- 面向对象:注重的是对象,无须清楚每一个步骤,只需要使用对象调用行为来完成需求
1.2 类的概述
类的概述
- 类是用来描述一类具有共同属性和行为事物的统称。所以其实类在客观世界里是不存在的，是抽象的，只是用来描述数据信息的。
- 人类: 描述信息
- 手机类: 描述信息
- 学生类: 描述信息
- 狗类: 描述信息
类的组成
- 属性：就是该事物的状态信息。
- 行为：就是该事物能够做什么。
举例
- 手机类
- 属性：品牌、价格…。
- 行为：打电话、发短信…。
小结
- 类是用来描述一群具有共同属性和行为事物的统称,类是抽象的,看不见,摸不着的,用来描述数据信息的
- 类的组成:
- 属性
- 行为
1.3 对象的概述
对象的概念
-
对象是类的一个实例(并不是你的女朋友哈)，具体存在的，看得见摸得着的，并且具备该类事物的属性和行为
- 对象的属性:对象的属性具有特定的值
- 对象的行为:对象可以操作的行为
-
人类: 描述信息 抽象
- 李四
- 张三
-
手机类: 描述信息
- 你手上的那台华为手机
-
学生类: 描述信息
- 学校里的张三
-
狗类: 描述信息
- 张三家的那条狗
举例
- 对象: 你手上拿的这台手机
- 属性：华为、1999…。 对象的属性具体的值,类中的属性没有具体的值
- 行为：使用打电话功能,使用发短信功能。对象可以使用行为
- 例如:
- 自行车---------->类
- 摩拜单车------->类
- 你早上骑得那辆摩拜单车---->对象
- …
小结
- 对象是类的实例,具体存在的,看得见摸得着的
- 对象的属性是有具体的值
- 对象的行为其实就是可以使用的功能\行为
1.4 类和对象的关系
类和对象的关系
-
类是对一类具有共同属性和行为的事物的统称,是抽象的
-
对象是一类事物的具体实例,看得见,摸的着的,真实存在的实体,是具体的
-
类是对象的抽象,对象是类的实体
小结
- 类是对象的抽象,对象是类的实体
- 类看成是对象的数据类型: (类是用来描述—群具有共同属性和行为的对象)
1.5 类的定义【应用】
类的组成是由属性和行为两部分组成
- 属性：该类事物的状态信息,在类中通过成员变量来体现（类中方法外的变量）
- 行为：该类事物有什么功能,在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
类的定义步骤
①定义类
②编写类的成员变量
③编写类的成员方法
类的定义格式
public class 类名 {// 定义一个类
// 类里面:属性(成员变量),行为(成员方法)
// 定义成员变量
数据类型 变量名1;
数据类型 变量名2;
...
// 定义成员方法
方法; 去掉static
}
/**
* 定义一个手机类,类名为(Phone),类的属性有:品牌(brand),价格(price),
* 类的行为:打电话(call),发短信(sendMessage)
*/
public class test01 {
//成员变量
String brand;
double price;
//成员方法
public void call(String phoneNum) {
System.out.println("正在给" + phoneNum + "打电话....");
}
public void sendMessage(String phoneNum, String message) {
System.out.println("正在给" + phoneNum + "发短信，短信内容是：" + message);
}
}
1.6 对象的创建和使用
对象的创建
- 创建对象的格式：
类名 对象名 = new 类名();- 类其实就是对象的数据类型,类是引用数据类型
- 例: Phone p1 = new Phone (); 创建了一个手机对象(Phone类的对象)
对象的使用
- 调用成员的格式：
- 访问成员变量
- 获取成员变量的值: 对象名.成员变量名
- 给成员变量赋值: 对象名.成员变量名=值;
- 访问成员方法
- 对象名.成员方法();
- 访问成员变量
案例演示
/*
对象的创建:
格式:类名对象名= new类名();
对象的使用:
访问成员变量 : 对象名.成员变量名
访问成员方法:
无返回值的方法:对象名.方法名(实参); ---->直接调用
有返回值的方法:
对象名.方法名(实参); ----->直接调用
数据类型 变量名 = 对象名.方法名(实参); ------>赋值调用
System.out.println(对象名.方法名(实参)); ---> 输出调用
成员变量有默认值:
整数类型:默认值是0
小数类型:默认值是0.0
布尔类型:默认值是false
字符类型:默认值是不可见
字符引用类型:默认值是null
*/
public class Test03 {
public static void main(String[] args) {
//创建手机对象
Test01 test01 = new Test01();
// 访问对象
// 访问成员变量
System.out.println(test01.brand);
System.out.println(test01.price);
// 给成员变量赋值
test01.brand = "华为";
test01.price = 4999.00;
// 访问成员变量
System.out.println(test01.brand);
System.out.println(test01.price);
// 访问成员方法
// 直接调用
test01.call("10086");
test01.sendMessage("10086","查询话费");
}
}
1.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();
}
}
1.8. 单个对象内存图
小结
- 只要创建对象,就会在堆区开辟一块空间
- 只要调用方法,就会在栈区开辟一块空间,用来执行该方法
1.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
}
}
小结
- 多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份
- 凡是new就会重新在堆区开辟一块新空间
- 对象和对象之间的关系是相互独立的
1.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);// 热巴
}
}
小结
- 当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）
- 只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。
1.11. 成员变量和局部变量的区别【理解】
- 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
- 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
- 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，随着方法的调用完毕而消失）
- 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）
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();
}
}
小结
位置不同: 成员变量定义在类中方法外,局部变量定义在方法中
在内存中的位置不同: 成员变量在堆区,局部变量在栈区
生命周期不同:
成员变量是随着对象的存在而存在,随着对象的销毁而销毁
局部变量是随着方法的调用而存在,随着方法的执行完毕而销毁
默认值不同:
成员变量用默认值,局部变量没有默认值
2. 封装
2.1 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方法的介绍
-
由于属性使用了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关键字
问题
我们发现 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内存原理
代码
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
}
}
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 (Application Programming Interface) ：应用程序编程接口。Java API是一本程序员的
字典，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。- API其实就是jdk中核心类库的说明文档
- 对于jdk中的核心类库只需要知道如何使用,无须关心他是如何实现的
API的使用步骤
- 打开API帮助文档。
- 点击显示，找到索引，看到输入框。
- 你要找谁？在输入框里输入，然后回车。
- 看包。java.lang下的类不需要导包，其他需要。
- 看类的解释和说明。
- 看构造方法。
- 看成员方法。
演示API的使用
- 打开帮助文档
- 找到索引选项卡中的输入框
- 在输入框中输入Random
- 看类在哪个包下
- 看类的描述
- 看构造方法
- 看成员方法
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.查看类的成员方法
250
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
