【26天高效学完Java编程】Day10：你真的理解面向对象的思想吗？

本专栏将从基础开始，循序渐进，由浅入深讲解Java的基本使用，希望大家都能够从中有所收获，也请大家多多支持。
专栏地址:26天高效学习Java编程
相关软件地址:软件地址
所有代码地址:代码地址
如果文章知识点有错误的地方，请指正！大家一起学习，一起进步。
如果感觉博主的文章还不错的话，还请关注、点赞、收藏三连支持一下博主哦

本文内容：

• 类和对象
  • 面向对象编程思想
  • 类的概述和定义----->掌握
  • 对象的创建和使用—>重点重点 掌握
  • 对象的内存图------>理解
  • 成员变量和局部变量
• 封装
  • private关键字使用
  • set\get方法
  • this关键字
• 构造方法
  • 定义和使用
  • JavaBean标准类制作
• API

看完能掌握以下知识点：

• 能够知道类和对象的关系
• 能够完成类的定义及使用
• 能够知道对象在内存中的初始化过程
• 能够知道局部变量和成员变量的区别
• 能够知道private关键字的特点
• 能够知道this关键字的作用
• 能够知道构造方法的格式和注意事项
• 能够完成一个标准类代码的编写及测试
• 能够知道帮助文档的使用步骤

知识点1-类和对象

知识点–1. 面向对象和面向过程编程思想

目标

• 理解面向过程和面向对象编程思想

讲解

编程思想其实就是编程思路,我们开发中2种经典的编程思想就是面向过程编程思想和面向对象编程思想.

面向过程编程思想

• 强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现

面向对象编程思想

• 强调的是对象, 通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

举例对比2种编程思想

• 洗衣服:

  • 面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
  • 面向对象: 把衣服脱下来–>给女朋友去洗

• 吃饭

  • 面向过程: 买菜—>洗菜—>切菜---->炒菜—>吃
  • 面向对象: 找个饭店–>20块钱

• java程序: 需求:打印数组中所有的元素,打印格式为: [元素1，元素2，元素3，元素，…，元素n]

  public class Test {public static void main(String[] args) {/*面向过程编程思想- 强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现面向对象编程思想- 强调的是对象, 通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。*/// 需求:打印数组中所有的元素,打印格式为: [元素1，元素2，元素3，元素，...，元素n]// 1 定义一个数组,并且初始化数组中的元素int[] arr = {10, 20, 30, 40, 50};// 面向过程:// 2.循环遍历数组for (int i = 0; i < arr.length; i++) {// 3.在循环中,获取遍历出来的元素int e = arr[i];// 4.判断该元素:if (i == 0) {// 4.1 如果该元素是第一个元素,打印格式: [ + 元素 + 逗号空格  不换行System.out.print("[" + e + ", ");} else if (i == arr.length - 1) {// 4.2 如果该元素是最后一个元素,打印格式: 元素 + ]System.out.println(e + "]");} else {// 4.3 如果该元素是中间元素,打印格式为: 元素 + 逗号空格   不换行System.out.print(e + ", ");}}System.out.println("==================================");// 面向对象:// jdk的api中有一个Arrays类toString()方法,可以帮助我们按照这种格式打印数组中的所有元素System.out.println(Arrays.toString(arr));}
  }
  

小结

• 面向过程:是一种编程思想
• 面向对象:是一种编程思想
• 区别:
  • 面向过程:注重的是过程,必须清楚每一个步骤,按照步骤一步一步去实现
  • 面向对象:注重的是对象,无须清楚每一个步骤,只需要使用对象调用行为来完成需求

知识点–2. 类的概述

目标

• 能够理解什么是类,以及类由什么组成

讲解

类的概述

• 类是用来描述一类具有共同属性和行为事物的统称。所以其实类在客观世界里是不存在的，是抽象的，只是用来描述数据信息的。
• 手机类—描述手机
• 人类---- 描述人

类的组成

• 属性：就是该事物的状态信息。
• 行为：就是该事物能够做什么。

举例

• 手机类
  • 属性：品牌、价格…。
  • 行为：打电话、发短信…。
• 人类:
  • 属性: 姓名,年龄,性别…
  • 行为:吃饭,睡觉,…

小结

• 类是用来描述一群具有共同属性和行为事物的统称,类是抽象的,看不见,摸不着的,用来描述数据信息的
• 类的组成:
  • 属性----共同拥有的
  • 行为----共同拥有的

知识点–3. 对象的概述

目标

• 理解什么是对象

讲解

对象的概念

• 对象是类的一个实例(并不是你的女朋友哈)，具体存在的，看得见摸得着的，并且具备该类事物的属性和行为
  • 对象的属性:对象的属性具有特定的值
  • 对象的行为:对象可以操作的行为

举例

• 对象: 你手上拿的这台手机
  • 属性：华为、1999。 对象的属性具体的值,类中的属性没有具体的值
  • 行为：使用打电话功能,使用发短信功能。对象可以使用行为

小结

• 对象是类的实例,具体存在的,看得见摸得着的
• 对象的属性是有具体的值
• 对象的行为其实就是可以使用的功能\行为

知识点–4. 类和对象的关系

目标

• 理解类和对象的关系

讲解

类和对象的关系

• 类是对一类具有共同属性和行为的事物的统称,是抽象的

• 对象是一类事物的具体实例,看得见,摸的着的,真实存在的实体,是具体的

• 类是对象的抽象,对象是类的实体

  

小结

• 对象是根据类来创建的,类中有什么,对象就有什么,可以把类看成是对象的数据类型

知识点–5. 类的定义【应用】

目标

• 掌握如何定义一个类

讲解

类的组成

类的组成是由属性和行为两部分组成

• 属性：该类事物的状态信息,在类中通过成员变量来体现（类中方法外的变量）
• 行为：该类事物有什么功能,在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤

①定义类

②编写类的成员变量

③编写类的成员方法

类的定义格式

public class 类名 {// 定义一个类// 类里面:属性(成员变量),行为(成员方法)// 定义成员变量数据类型 变量名1;数据类型 变量名2;...// 定义成员方法方法;  去掉static
}

举例

• 定义一个手机类,类名为(Phone),类的属性有:品牌(brand),价格(price),类的行为:打电话(call),发短信(sendMessage)

public class Phone {//属性(成员变量): 数据类型 变量名;/*** 品牌*/String brand;/*** 价格*/double price;//行为(成员方法): 去掉static/*** 打电话的功能* @param phoneNum 电话号码*/public void call(String phoneNum){System.out.println("正则给"+phoneNum+"打电话...");}/*** 发短信的功能* @param phoneNum 电话号码* @param 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 {//属性(成员变量): 数据类型 变量名;/*** 品牌*/String brand;/*** 价格*/double price;//行为(成员方法): 去掉static/*** 打电话的功能* @param phoneNum 电话号码*/public void call(String phoneNum){System.out.println("正在给"+phoneNum+"打电话...");}/*** 发短信的功能* @param phoneNum 电话号码* @param message  短信内容*/public void sendMessage(String phoneNum,String message){System.out.println("正在给"+phoneNum+"发送短信,短信内容是:"+message);}// 为了演示有返回值的方法调用public int show(String str){System.out.println("有参数有返回值的方法:"+str);return 100;}
}public class Test {public static void main(String[] args) {/*对象的创建和使用:对象的创建:对象创建格式: 类名 对象名 = new 类名();结论: 类其实也是一种数据类型,是引用数据类型对象的使用:访问成员变量:给成员变量赋值:  对象名.成员变量名 = 值;获取成员变量的值: 对象名.成员变量名访问成员方法:调用方法: 有返回值的方法,无返回值的方法无返回值的方法:直接调用: 对象名.方法名(实参);有返回值的方法:直接调用: 对象名.方法名(实参);赋值调用: 数据类型 变量名 = 对象名.方法名(实参);输出调用: System.out.println(对象名.方法名(实参));*/// 创建Phone类的对象Phone p1 = new Phone();// 给p1对象的brand成员变量赋值p1.brand = "华为";// 给p1对象的price成员变量赋值p1.price = 999.8;// 获取p1对象的brand成员变量的值System.out.println(p1.brand);// 获取p1对象的price成员变量的值System.out.println(p1.price);// 无返回值的成员方法// 使用p1对象调用call方法p1.call("10086");// 使用p1对象调用sendMessage方法p1.sendMessage("10086","请问一下联通的客服电话号码是多少?");System.out.println("==============================");// 有返回值的方法// 直接调用p1.show("hashnode");// 赋值调用int res = p1.show("itcast");// 100System.out.println("res:"+res);// 100// 输出调用System.out.println(p1.show("java"));// 100/*之前访问变量int num;num = 10;System.out.println(num);*//*之前访问访问方法分类: 无参数无返回值,有参数无返回值,有参数有返回值,无参数有返回值调用方法: 有返回值的方法,无返回值的方法无返回值的方法:直接调用: 方法名(实参);有返回值的方法:直接调用: 方法名(实参);赋值调用: 数据类型 变量名 = 方法名(实参);输出调用: System.out.println(方法名(实参));*/}
}

小结

	创建对象的格式:类名 对象名 = new 类名();使用对象:访问类的成员变量:获取成员变量的值: 对象名.成员变量名给成员变量赋值:   对象名.成员变量名 = 值;访问类的成员方法:成员方法无返回值:  对象名.成员方法(实参);成员方法有返回值:对象名.成员方法(实参);  直接调用数据类型 变量名 = 对象名.成员方法(实参); 赋值调用System.out.println(对象名.成员方法(实参));输出调用

实操–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+","+stu.age);// 冰冰,18// 访问成员方法stu.study();stu.doHomeWork();}
}

小结

略

知识点–成员变量默认值

public class Student {/*** 姓名*/String name;/*** 年龄*/int age;/*** 分数*/double score;char c;
}public class Test {public static void main(String[] args) {// 变量的要使用一定要赋值//int num;// 局部变量:定义在方法中的变量//System.out.println(num);// 编译报错,局部变量没有默认值/*成员变量的默认值:整数类型: 默认值是0小数类型: 默认值是0.0布尔类型: 默认值是false字符类型: 默认值是不可见字符 '\u0000'引用类型: 默认值是null*/// 创建Student对象Student stu = new Student();// 访问成员变量System.out.println(stu.name);// nullSystem.out.println(stu.age);// 0System.out.println(stu.score);// 0.0System.out.println("="+stu.c+"=");}
}

知识点–8. 单个对象内存图

目标

• 掌握单个对象的内存图

路径

• 查看程序案例
• 绘制内存图

讲解

查看程序案例

代码

public class Student {// 成员变量: 属性/*** 姓名*/String name;/*** 年龄*/int age;// 成员方法: 行为/*** 学习的功能*/public void study(){System.out.println("学生正在学习Java...");}/*** 做作业的功能*/public void doHomeWork(){System.out.println("学生正在做作业敲代码...");}
}package com.hashnode.demo6_单个对象内存图;public class Test {public static void main(String[] args) {// 创建Student对象Student stu = new Student();System.out.println(stu);// 十六进制数地址值// 访问成员变量stu.name = "冰冰";stu.age = 18;System.out.println(stu.name+","+stu.age);// 访问成员方法stu.study();stu.doHomeWork();}
}

小结

• 只要创建对象,就会在堆区开辟一块空间(凡是new就会在堆区开辟一块新的空间)
• 只要调用方法,就会在栈区开辟一块空间,用来执行该方法

知识点–9. 多个对象内存图

目标

• 掌握多个对象的内存图

讲解

查看程序案例

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对象  shift+f6+fn 批量修改名称Student stu1 = new Student();System.out.println(stu1);// 十六进制数地址值// 访问成员变量stu1.name = "冰冰";stu1.age = 18;System.out.println(stu1.name+","+stu1.age);// 冰冰,18// 访问成员方法stu1.study();stu1.doHomeWork();System.out.println("==========================");Student stu2 = new Student();System.out.println(stu2.name+","+stu2.age);// null,0stu2.study();}
}

绘制内存图

小结

• 多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自对象的内存区域中，成员方法多个对象共用的一份
• 凡是new就会重新在堆区开辟一块新空间
• 对象和对象之间的关系是相互独立的

知识点–10. 多个变量指向相同对象内存图

目标

• 掌握多个变量指向相同对象内存图

讲解

查看程序案例

public class Student {String name;// 姓名int age;// 年龄public void study(){System.out.println(name+"正在学习...");}}
public class Test {public static void main(String[] args) {// 创建Student对象Student stu1 = new Student();// 给stu1对象的属性赋值stu1.name = "冰冰";stu1.age = 18;System.out.println(stu1.name + "," + stu1.age);// 冰冰,18// 把stu1赋值给stu2Student stu2 = stu1;System.out.println(stu2.name + "," + stu2.age);// 冰冰,18stu2.name = "空空";System.out.println(stu1.name + "," + stu1.age);// 空空,18}
}

绘制内存图

小结

• 当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）
• 只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。

知识点–11. 成员变量和局部变量的区别

目标

• 理解成员变量和局部变量的区别

路径

• 成员变量和局部变量的区别

讲解

• 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
• 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
• 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，随着方法的调用完毕而消失）
• 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

public class Car {String color;// 成员变量// 成员方法public void drive(){int speed = 80;System.out.println("汽车正在以"+speed+"迈的速度行驶...");}
}public class Test {/*成员变量和局部变量的区别:定义的位置不同: 成员变量定义在类中方法外,局部变量定义在方法中在内存中的位置不同: 成员变量是在堆区,局部变量是在栈区生命周期不同:成员变量是随着对象的创建而存在,随着对象的销毁而销毁局部变量是随着方法的调用而存在,随着方法调用完毕而销毁默认值不同:成员变量有默认值局部变量没有默认值,不赋值不能直接使用*/public static void main(String[] args) {// 创建Car对象Car car = new Car();// 调用方法car.drive();}
}

小结

略

知识点–2. 封装

知识点–2.1 private关键字

目标

• 理解private关键字的含义和使用格式

讲解

private的含义

• 概述: private是一个权限修饰符，代表最小权限。
• 特点:
  • 可以修饰成员变量和成员方法。
  • 被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式

// private关键字修饰成员变量
private 数据类型 变量名 ；// private关键字修饰成员方法
private 返回值类型 方法名(参数列表){代码
}

案例

public class Student {String name;// 姓名// private修饰成员变量private int age;// 年龄public void eat(){System.out.println("吃东西的方法");}// private修饰成员方法private void sleep(){System.out.println("睡觉的方法");}// show方法public void show(){System.out.println(name);System.out.println(age);eat();sleep();}
}
public class Test {public static void main(String[] args) {/*private关键字:概述:private是一个关键字,表示最小的访问权限使用:修饰成员变量: private 数据类型 变量名;修饰成员方法: 在方法的返回值类型前面加一个privateprivate 数据类型 方法名(参数列表){ 方法体 }特点: 被private修饰后的成员变量和成员方法，只在本类中才能访问。*/// 创建Student类对象Student stu = new Student();// 访问成员变量System.out.println(stu.name);//System.out.println(stu.age);// 编译报错,因为private修饰的成员变量只能在本类中访问// 访问成员变量和成员方法stu.eat();//stu.sleep();// 编译报错,因为private修饰的成员方法只能在本类中访问// 调用show方法,间接访问私有成员stu.show();}
}

小结

- private的含义: private是一个权限修饰符,表示最小的权限- private的使用: 修饰成员变量和成员方法修饰成员变量的格式:  private 数据类型 变量名;修饰成员方法的格式:  private 返回值类型 方法名(参数列表){...}- 特点: 被private修饰的成员变量或者成员方法,只能在本类中访问

知识点–2.2 对属性封装

目标

• 理解对属性封装

路径

• 为什么要对属性进行封装
• 对属性封装的步骤

讲解

为什么要对属性进行封装

public class Student {String name;// 姓名int age;// 年龄public void show(){System.out.println("姓名:"+name+",年龄:"+age);}
}public class Test {public static void main(String[] args) {// 创建Student对象Student stu = new Student();// 给stu对象的属性赋值stu.name = "冰冰";stu.age = -18;// 调用show方法stu.show();// 姓名:冰冰,年龄:-18}
}

• 通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患,应该怎么解决呢?
• 解决方式: 不让外界直接访问成员变量(也就是要对属性进行封装)

对属性封装的步骤

1. 使用private修饰成员变量

   public class Student {private String name;// 姓名private int age;// 年龄public void show(){System.out.println("姓名:"+name+",年龄:"+age);}
   }
   

2. 对需要访问的成员变量,提供对应的getXxx方法(获取属性的值) 、setXxx 方法(给属性赋值)。

小结

• 使用private修饰成员变量
• 为private修饰的成员变量提供公共的访问方式(set\get方法)

知识点–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;// 年龄// 赋值方式: set方法public void setName(String n) {name = n;}public void setAge(int a) {if (a < 0 || a > 120) {age = -1;} else {age = a;}}// 取值方式: get方法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 stu = new Student();// 给stu对象的属性赋值 ----直接通过对象名点的方式来访问//stu.name = "冰冰";//stu.age = -18;// 通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患,应该怎么解决呢?// 解决方式: 不让外界直接访问成员变量(也就是要对属性进行封装)// 步骤:// 1.使用private修饰成员变量// 2.为成员变量提供公共的访问方式(set\get方法)//  给stu对象的属性赋值 ----通过对象名调用set\get方法来访问stu.setName("冰冰");stu.setAge(-18);// 取stu对象的属性值System.out.println(stu.getName()+","+stu.getAge());// 冰冰,-1// 调用show方法stu.show();// 姓名:冰冰,年龄:18}
}

小结

• 略

知识点–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;// 年龄// 赋值方式: set方法public void setName(String name) {this.name = name;}public void setAge(int age) {if (age < 0 || age > 120) {this.age = -1;} else {this.age = age;}}// 取值方式: get方法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) {/*问题1:setXxx 方法中的形参名字并不符合见名知意的规定，解决1:修改形参名与成员变量名一致问题2:经过修改和测试，我们发现新的问题，局部变量和成员变量名相同,导致成员变量赋值失败了解决2:使用this关键字来区分同名的成员变量和局部变量this关键字:概述: this表示当前对象(谁调用this所在的方法,谁就是当前对象)使用: this.成员变量名*/// 创建Student对象Student stu = new Student();// 给属性赋值stu.setName("冰冰");stu.setAge(18);// 打印属性的值System.out.println(stu.getName()+","+stu.getAge());// 冰冰,18}
  }

  小贴士：方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。

小结

 this关键字:1.作用: 用来区分同名的成员变量和局部变量2.格式: this.成员变量名3.this含义:代表当前对象当前对象: 谁调用this所在的方法,谁就是当前对象

知识点–2.5 this内存原理

目标

• 加深对this的理解

讲解

代码

public class Student {private String name;// 姓名private int age;// 年龄// 赋值方式: set方法public void setName(String name) {this.name = name;}public void setAge(int age) {if (age < 0 || age > 120) {this.age = -1;} else {this.age = age;}}// 取值方式: get方法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 stu = new Student();// 给属性赋值stu.setName("冰冰");stu.setAge(18);// 打印属性的值System.out.println(stu.getName()+","+stu.getAge());// 冰冰,18}
}

小结

• this表示当前对象(哪个对象调用this所在的方法,this就表示哪个对象)

知识点–2.6 封装概述

目标:

• 理解封装的概念

路径:

• 封装概述

讲解:

封装概述

• 是面向对象三大特征之一（封装，继承，多态）
• 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

封装原则

• 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
• 例如:成员变量使用private修饰，提供对应的getXxx()/setXxx()方法

封装好处

• 通过方法来控制成员变量的操作，提高了代码的安全性
• 把代码用方法进行封装，提高了代码的复用性

小结

略

知识点–3. 构造方法

知识点–3.1 构造方法概述

目标

• 能够理解构造方法的作用和能够定义构造方法

路径

• 构造方法的概述
• 构造方法的定义

讲解

构造方法的概述

• 构造方法是一种特殊的方法,主要是完成对象的创建和对象数据的初始化

构造方法的定义

• 格式

  // 空参构造方法
  修饰符 类名(){}// 有参构造方法
  修饰符 类名(参数列表){// 方法体
  }

• 特点:

  • 构造方法的写法上，方法名与它所在的类名相同
  • 构造方法没有返回值，所以不需要返回值类型，甚至不需要void

• 示例代码：

public class Student {private String name;private int age;// 空参构造方法public Student(){}// 有参构造方法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.构造方法的名字就是类名2.构造方法没有返回值,连void都不能写3.通过new来调用构造方法- 构造方法的定义空参构造方法public 类名(){}有参构造方法public 类名(形参){给成员变量赋值}*/// 创建Student类的对象Student stu1 = new Student();Student stu2 = new Student("冰冰",18);// 调用show方法stu1.show();// null,0stu2.show();// 冰冰,18}
}

小结

 构造方法的概述- 构造方法是一种特殊的方法,主要是完成对象的创建和对象属性的初始化构造方法的定义- 格式:空参构造方法修饰符 类名(){}有参构造方法修饰符 类名(参数){方法体(给属性赋值)}- 特点:1.构造方法的方法名和类名一致2.构造没有返回值,连void都没有3.构造方法可以重载调用构造方法: 通过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;}public void show(){System.out.println(name+","+age);}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.如果定义了构造方法，系统将不再提供默认的构造方法3.构造方法只能给属性赋值一次,不能重复赋值,而set方法可以重复赋值因为每调用一次构造方法就是新创建一个对象4.构造方法可以重载*/Student stu1 = new Student();Student stu2 = new Student("冰冰",18);stu2.show();// 冰冰,18// 修改姓名为小冰冰stu2.setName("小冰冰");// 调用show方法stu2.show();// 小冰冰,18}
}

小结

构造方法的注意事项:- 构造方法的创建- 如果没有定义构造方法，系统将给出一个默认的无参数构造方法- 如果定义了构造方法，系统将不再提供默认的构造方法- 构造方法只能给属性赋值一次,不能重复赋值,可以谁有set方法给属性重复赋值- 构造方法可以重载，既可以定义参数，也可以不定义参数。- 定义构造方法的时候,不要写返回值,连void都不能有- 定义构造方法的时候,构造方法名和类名一定要一致

知识点–3.3 标准类制作

目标

• 掌握标准类的制作

路径

• 标准类的组成
• 案例演示

讲解

标准类的组成

JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求类必须是公共的，属性使用private修饰,并且具有无参数的构造方法，提供用来操作成员变量的set 和get 方法。

public class ClassName{//成员变量  private//构造方法//无参构造方法【必须】//满参构造方法【建议】//getXxx()//setXxx()//成员方法	
}

案例演示

• 需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。
• 示例代码：

public class Student {// 成员变量---privateprivate String name;// 姓名private int age;// 年龄// 空参构造方法  alt+insert+Constructorpublic Student() {}// 满参构造方法  alt+insert+Constructorpublic Student(String name, int age) {this.name = name;this.age = age;}// set\get方法  alt+insert+getter and setterpublic 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);}
}

小结

• 标准类
  • 成员变量----private
  • 空参构造
  • 满参构造
  • set\get方法
  • 成员方法

知识点–4. API

目标

• 了解API的概念和使用步骤

路径

• API的概念
• API的使用步骤
• 演示API的使用

讲解

API的概念

• 什么是API

  ​ API (Application Programming Interface) ：应用程序编程接口。Java API是一本程序员的字典 ，是JDK中提供给我们使用的类的说明文档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。所以我们可以通过查询API的方式，来学习Java提供的类，并得知如何使用它们。

  • API其实就是jdk中核心类库的说明文档
  • 对于jdk中的核心类库只需要知道如何使用,无须关心他是如何实现的

API的使用步骤

1. 打开API帮助文档。
2. 点击显示，找到索引，看到输入框。
3. 你要找谁？在输入框里输入，然后回车。
4. 看包。java.lang下的类不需要导包，其他需要。
5. 看类的解释和说明。
6. 看构造方法。
7. 看成员方法。

演示API的使用

• 打开帮助文档

• 找到索引选项卡中的输入框

  

• 在输入框中输入Random

• 看类在哪个包下

• 看类的描述

• 看构造方法

• 看成员方法

public class Test {public static void main(String[] args) {/*API的使用步骤:1.打开api文档2.点击显示3.点击索引,在输入框中输入要查找的内容4.查看包--->只要不是在java.lang包下,使用的时候都需要导包5.查看类的解释说明--->使用场景6.查看构造方法 --->创建对象7.查看成员方法 --->功能举例: Scanner1.查看包  java.util包--需要导包2.查看类的解释说明    Scanner类是表示扫描器,可以用来扫描基本类型和字符串类型的数据3.查看构造方法Scanner(InputStream source) 构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。4.查看成员方法byte nextByte()short nextShort()short nextInt()Long nextLong()boolean nextBoolean()double nextDouble()float nextFloat()String nextLine()  可以获取一行字符串   空格,回车,tab键都可以获取String next()      可以获取单个字符串   空格,回车,tab键都不可以获取*/Scanner sc = new Scanner(System.in);System.out.println("请输入年龄:");int age = sc.nextInt();System.out.println("年龄是:"+age);System.out.println("请输入姓名:");String name = sc.next();// 这里不能使用nextLine,因为会获取上一次输入的回车System.out.println("姓名是:"+name);//System.out.println("请输入一个字符串");//String next = sc.next();//System.out.println(next);//String next = sc.nextLine();//System.out.println(next);/*System.out.println("请输入小数:");double num = sc.nextDouble();System.out.println(num);System.out.println("请输入boolean类型的值:");boolean b = sc.nextBoolean();if (b == true){System.out.println("true");}else{System.out.println("false");}*/}
}