知识点1-类和对象
知识点–1. 面向对象和面向过程编程思想
**
讲解
**
编程思想其实就是编程思路,我们开发中2种经典的编程思想就是面向过程编程思想和面向对象编程思想.
面向过程编程思想
- 强调的是过程,必须清楚每一个步骤,然后按照步骤一步一步去实现
- 强调的是对象, 通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。
举例对比2种编程思想
-
洗衣服:
- 面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
- 面向对象: 把衣服脱下来–>给女朋友去洗
-
吃饭
- 面向过程: 买菜—>洗菜—>炒菜—>吃
- 面向对象: 找个饭店–>10块钱
-
java程序:需求:打印数组中所有的元素,打印格式为: [元素1，元素2，元素3，元素，…，元素n]
import java.util.Arrays;
public class Test {
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));
}
}
小结
- 面向过程:是一种编程思想
- 面向对象:是一种编程思想
- 区别:
- 面向过程:注重的是步骤,必须清楚每一个步骤,按照步骤一步一步去实现
- 面向对象::注重的是对象,无须清楚每一个步骤,只需要使用对象调用行为来完成需求
知识点–2. 类的概述
讲解
类的概述
- 类是用来描述一类具有共同属性和行为事物的统称。所以其实类在客观世界里是不存在的，是抽象的，只是用来描述数据信息的。
- 人类: 描述信息
- 手机类: 描述信息
- 学生类: 描述信息
- 狗类: 描述信息
- …
类的组成
- 属性: 就是该事物的状态信息。
- 行为: 就是该事物能够做什么。
举例
- 手机类
- 属性：品牌、价格…。
- 行为：打电话、发短信…。
小结
- 类是用来描述一群具有共同属性和行为事物的统称,类是抽象的,看不见,摸不着的,用来描述数据信息的
- 类的组成:
- 属性
- 行为
知识点–3. 对象的概述
讲解
对象的概念
- 对象是类的一个实例(并不是你的女朋友哈)，具体存在的，看得见摸得着的，并且具备该类事物的属性和行为
- 对象的属性:对象的属性具有特定的值
- 对象的行为:对象可以操作的行为 - 人类: 描述信息 抽象
- 李四
- 张三
- 手机类: 描述信息
- 你手上的那台华为手机
- 学生类: 描述信息
- 106期的张三
- 狗类: 描述信息
- 张三家的那条狗
举例
- 对象: 你手上拿的这台手机
- 属性：华为、1999…。 对象的属性具体的值,类中的属性没有具体的值
- 行为：使用打电话功能,使用发短信功能。对象可以使用行为
- 例如:
- 自行车---------->类
- 摩拜单车------->类
- 你早上骑得那辆摩拜单车---->对象
- …
小结
- 对象是类的实例,具体存在的,看得见摸得着的
- 对象的属性是有具体的值
- 对象的行为其实就是可以使用的功能\行为
知识点–4. 类和对象的关系
讲解
类和对象的关系
- 类是对一类具有共同属性和行为的事物的统称,是抽象的
- 对象是一类事物的具体实例,看得见,摸的着的,真实存在的实体,是具体的
- 类是对象的抽象,对象是类的实体
知识点–5. 类的定义【应用】
讲解
复习类的组成
类的组成是由属性和行动两部分组成
- 属性:该类事物的状态信息,在类中通过成员变量来体现（类中方法外的变量）
- 该类事物有什么功能,在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）
类的定义步骤
- 定义类
- 编写类的成员变量
- 编写类的成员方法
类的定义格式
public class 类名 {// 定义一个类
// 类里面:属性(成员变量),行为(成员方法)
// 定义成员变量
数据类型 变量名1;
数据类型 变量名2;
...
// 定义成员方法
方法; 去掉static
}
举例
- 定义一个手机类,类名为(Phone),类的属性有:品牌(brand),价格(price),类的行为:打电话(call),发短信(sendMessage)
public class Phone {//定义一个手机类
//定义属性(成员变量)
String brand;
double price;
//定义行为(成员方法)
public void call(String phoneNum) {
System.out.println("打电话给"+phoneNum);
}
public void sendMessage(String phoneNum,String message) {
System.out.println("发"+message+"给"+phoneNum);
}
}
小结
- 定义类的格式
public class 类名{//定义一个类
//类里面:属性(成员变量) 行为(成员方法)
//定义成员变量
数据类型 变量名1;
数据类型 变量名2;
...
//定义成员方法
方法(去掉static)
}
知识点–6. 对象的创建和使用
讲解
对象的创建
- 创建对象的格式：
- 类名 对象名 = new 类名();
- 类其实就是对象的数据类型,类是引用数据类型
- 例: Phone p1 = new Phone (); 创建了一个手机对象(Phone类的对象)
对象的使用
-
调用成员的格式：
- 访问成员变量
- 获取成员变量的值: 对象名.成员变量名
- 给成员变量赋值: 对象名.成员变量名=值;
- 访问成员变量
-
访问成员方法
- 对象名.成员方法();
案例演示
public class Phone {//定义一个手机类
//定义属性(成员变量)
String brand;
double price;
//定义行为(成员方法)
public void call(String phoneNum) {
System.out.println("打电话给"+phoneNum);
}
public void sendMessage(String phoneNum,String message) {
System.out.println("发"+message+"给"+phoneNum);
}
}
public class Test01 {
public static void main(String[] args) {
/*
* 对象的创建(重点)
* 格式: 类名 对象名 =new 类名();
*
* 对象的使用:
* 访问成员变量:对象名.成员变量名
*
* 成员变量有默认值:
* 整数类型:默认值是0
* 小数类型:默认值是0.0
* 布尔类型:默认值是false
* 字符类型:默认值是不可见字符
* 引用类型:默认值是null
*
* 访问成员方法(重点):
* 无返回值的方法:对象名.方法名(实参);----->直接调用
* 有返回值的方法:对象名.方法名(实参);----->直接调用
* 数据类型 变量名=对象名.方法名(实参);------>赋值调用(开发中常用)
* */
//创建手机对象
Phone p1 = new Phone();
//访问成员变量
System.out.println(p1.brand);
System.out.println(p1.price);
//给成员变量赋值
p1.brand="苹果";
p1.price=5999.9;
//取值
System.out.println(p1.brand);
System.out.println(p1.price);
System.out.println("===================================");
//访问成员方法
p1.call("10010");
p1.sendMessage("10010","cxll");
}
}
小结
对象的创建(重点):
格式: 类名 对象名 = new 类名();
对象的使用:
访问成员变量: 对象名.成员变量名
访问成员方法(重点):
无返回值的方法: 对象名.方法名(实参); ------>直接调用
有返回值的方法:
对象名.方法名(实参); ------>直接调用
数据类型 变量名 = 对象名.方法名(实参); ------>赋值调用 开发中
成员变量有默认值:
整数类型: 默认值是0
小数类型: 默认值是0.0
布尔类型: 默认值是false
字符类型: 默认值是不可见字符
引用类型: 默认值是null
实操–7. 学生对象-练习
需求
- 首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用
分析
- 定义学生类
- 成员变量：姓名，年龄…
- 成员方法：学习，做作业…
- 测试类
- 创建main方法,在main 方法中创建学生对象
- 使用学生对象访问成员变量和访问成员方法
package com.bb;
public class Student {
String name;
int age;
public void study() {
System.out.println("正在学习..");
}
public void doHomework() {
System.out.println("正在做作业...");
}
}
package com.bb;
public class StudentTest {
public static void main(String[] args) {
Student s1 = new Student();
//给成员变量赋值
s1.name="香茗";
s1.age=18;
System.out.println(s1.name);
System.out.println(s1.age);
//使用对象访问成员方法
s1.study();
s1.doHomework();
}
}
知识点–8. 单个对象内存图
小结
- 只要创建对象,就会在堆区开辟一块空间
- 只要调用方法,就会在栈区开辟一块空间,用来执行该方法
知识点–9. 多个对象内存图【理解】
小结
- 多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份
- 凡是new就会重新在堆区开辟一块新空间
- 对象和对象之间的关系是相互独立的
知识点–10. 多个变量指向相同对象内存图【理解】
小结
- 当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）
- 只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。
知识点–11. 成员变量和局部变量的区别【理解】
讲解
- 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
- 内存中位置不同：成员变量(堆内存) 局部变量(栈内存)
- 生命周期不同：成员变量(随着对象的存在而存在,随着对象的消失而消失) 局部变量(随着方法的调用而存在,随着方法的调用完毕而消失)
- 初始化值不同：成员变量(有默认初始值) 局部变量(没有默认初始化值,必须先定义,赋值才能使用)
知识点–2. 封装
知识点–2.1 private关键字
讲解
private的含义
- 概述: private是一个权限修饰符，代表最小权限。
- 特点:
- 可以修饰成员变量和方法
- 被private修饰后的成员变量和成员方法,只在本类中使用
private的使用格式
// private关键字修饰成员变量
private 数据类型 变量名 ；
// private关键字修饰成员方法
private 返回值类型 方法名(参数列表){
代码
}
package com.bb;
public class Student1 {
String name;
private int age;
public void study() {
System.out.println("正在学习java....");
}
private void doHome() {
System.out.println("正在当天写布置的java代码");
}
}
package com.bb;
public class Test01 {
public static void main(String[] args) {
Student1 s1 = new Student1();
s1.name = "哈哈";
s1.study();
}
}
小结
- 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
}
- 通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患,应该怎么解决呢?
- 解决方式: 不让外界直接访问成员变量(也就是要对属性进行封装)
对属性封装的步骤
1.使用private修饰成员变量
public class Student {
// 成员变量
private String name;// 姓名
private int age;// 年龄
}
2.对需要访问的成员变量,提供对应的getXxx方法(获取属性的值) 、setXxx 方法(给属性赋值)。
知识点–2.3 set和get方法
讲解
set和get方法的介绍
- 由于属性使用了private关键字修饰,在其他类中无法直接访问,所以得提供**公共的访问方法,**我们把这张方法叫做set和get方法
- get方法: 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
- set方法: 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰
set和get方法的书写
package com.bb;
public class Student2 {
//成员变量
private String name;
private int age;
//成员方法
public void setName(String n) {
name = n;
}
public void setAge(int a) {
if (a < 0 || a > 145) {
age = 0;
} else {
age = a;
}
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
package com.bb;
public class Test02 {
public static void main(String[] args) {
/*
* 为什么对属性进行封装
* 通过对象名直接访问成员变量的方式来对属性赋值,会存在数据安全隐患
*
* 对属性进行封装
* 1.使用private关键字修饰成员变量(属性)
* 2.提供公共的成员方法用来给属性赋值和取值(set\get方法)
* */
//创建对象
Student2 s1 = new Student2();
//赋值
s1.setName("超人");
s1.setAge(2000);//数据不合法
//取值
System.out.println(s1.getName());
System.out.println(s1.getAge());
}
}
知识点–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 修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：
package com.bb;
public class Student2 {
//成员变量
private String name;
private int age;
//成员方法
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
if (age < 0 || age > 145) {
this.age = 0;
} else {
this.age = age;
}
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
在这里插入代码片
小贴士：方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。
小结
this关键字:
1.作用: 用来区分同名的成员变量和局部变量
2.格式: this.成员变量名
3.this含义:代表当前对象
当前对象: 谁调用this所在的方法,谁就是当前对象
知识点–2.5 this内存原理
讲解
略
知识点–2.6 封装概述
讲解
封装概述
- 是面向对象三大特征之一(封装,继承,多态)
- 是面向对象编程语言对客观世界的模拟,客观世界里成员变量都是隐藏在对象内部的,外界是无法直接操作
封装原则
- 将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
- 例如:成员变量使用private修饰,提供对应的getXxx()/setXxx()方法
封装好处
- 通过方法来控制成员变量的操作,提高了代码的安全性
- 把代码用方法进行封装,提高了代码的复用性
知识点–3. 构造方法
知识点–3.1 构造方法概述
讲解
构造方法的概述
- 构造方法是一种特殊的方法,主要是完成对象的创建和对象数据的初始化
构造方法的定义
- 格式
//空参构造方法
修饰符 类名(){
}
//有参构造方法
修饰符 类名(参数列表){
//方法体
}
- 特点:
- 构造方法的写法上,方法名与它所在的类名相同
- 构造方法没有返回值,所以不需要返回值类型,甚至不需要void
- 示例代码
package com.bb;
public class Student3 {
//成员变量
private String name;
private int age;
//构造方法
//空参构造方法
public Student3(){
System.out.println("空参构造方法");
}
//有参构造方法
public Student3(String name,int age){
this.name =name;
this.age=age;
}
//成员方法
public void show(){
System.out.println(name+","+age);
}
}
package com.bb;
public class Test03 {
public static void main(String[] args) {
/*
* 构造方法的概述
* 概述:构造方法是一种比较特殊的方法
* 作用:主要用来创建队象,并给对象的属性初始化
* 特点:
* 1.构造方法没有返回值,连void都不能写
* 2.构造方法的方法名必须和类名一致
* 3.通过new来调用构造方法
*
* 构造方法的定义
* 空参构造:
* public 类名(){
* }
* 有参构造:
* public 类名(形参){
* 给属性赋值
* }
* */
//调用空参构造方法,创建对象
Student3 s3 = new Student3();
s3.show();
//调用有参构造方法,创建对象
Student3 s33 = new Student3("哈哈", 19);
s33.show();
}
}
小结
构造方法的概述
- 构造方法是一种特殊的方法,主要是完成对象的创建和给对象的属性进行初始化
构造方法的定义
- 格式:
空参构造方法
修饰符 类名(){
}
有参构造方法
修饰符 类名(参数){
方法体(给属性赋值)
}
- 特点:
1.构造方法的方法名和类名一致
2.构造没有返回值,连void都没有
调用构造方法: 通过new来调用
知识点–3.2 构造方法的注意事项
讲解
- 构造方法的创建
- 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
- 如果定义了构造方法，系统将不再提供默认的构造方法
- 构造方法可以重载，既可以定义参数，也可以不定义参数。
- 示例代码
package com.bb;
public class Student4 {
private String name;
private int age;
//构造方法
//空参构造方法
public Student4() {
}
//有参构造方法
public Student4(String name) {
this.name = name;
}
public Student4(int age) {
this.age = age;
}
//满参构造方法
public Student4(String name, int age) {
this.name = name;
this.age = age;
}
//set/get方法
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
package com.bb;
public class Test4 {
/*
* 构造方法的注意事项:
* 1.定义构造方法,方法名一定要和类名一致
* 2.定义构造方法,一定没有返回值类型,连void都不能写
* 3.如果一个类没有定义构造方法,系统会默认生成一个空参构造方法
* 4.如果一个类定义了构造方法,系统就不会默认生成一个空参构造方法
* 5.构造方法是可以重载的
* 6.构造方法只能给属性赋值一次,而set方法可以反复给属性赋值
*
* */
public static void main(String[] args) {
//通过调用空参构造方法,创建Student对象
Student4 s4 = new Student4();
s4.setName("nini");
s4.setAge(18);
System.out.println(s4.getName() + "," + s4.getAge());
//通过调用满参构造方法,创建Student对象
Student4 ss4 = new Student4("meimei", 17);
System.out.println(ss4.getName()+","+ss4.getAge());
}
}
小结
构造方法的注意事项:
-构造方法的创建
- 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
- 如果定义了构造方法，系统将不再提供默认的构造方法
- 构造方法可以重载，既可以定义参数，也可以不定义参数。
- 定义构造方法的时候,不要写返回值,连void都不能有
- 定义构造方法的时候,构造方法名和类名一定要一致
知识点–3.3 标准类制作
讲解
标准类的组成
JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求类必须是公共的，属性使用private修饰,并且具有无参数的构造方法，提供用来操作成员变量的set 和get 方法。
public class ClassName{
//成员变量 private
//构造方法
//空参构造方法(必须)
//满参构造方法(建议)
//getXxx()
//setXxx()
//成员方法
}
案例演示
- 需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。
- 示例代码：
package com.bb;
public class Student5 {
//需求：定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。
//成员变量
private String name;
private int age;
//空参构造方法--->快捷键: alt+insert--->Constructor
public Student5(){
}
//满参构造方法
public Student5(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(){
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下的类不需要导包，其他需要。
- 看类的解释和说明。
- 看构造方法。
- 看成员方法。
2041
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
