04 面向对象与封装- 类和对象、对象作为方法的参数、对象作为方法返回值、封装、private关键字的使用、this关键字、构造方法、定义一个标准的类
04-面向对象与封装
1. 面向对象思想的概述
概述
Java语言是一种面向对象的程序设计语言,而面向对象思想是一种程序设计思想,我们在面向对象思想的指引下, 使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物,每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征抽象出来,描述成计算机事件的设计思想。 它区别于面向过程思想,强调的是通过调用对象的行为来实现功能,而不是自己一步一步的去操作实现。
- 面向过程:强调步骤。
- 面向对象:强调对象。
特点
三大基本特征:封装、继承和多态。
面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲力亲为,详细处理每一个细节。
面向对象:当需要实现一个功能的时候,不关心具体的步骤,而是找一个已经具有该功能的人,来帮我做事儿。
import java.util.Arrays; public class Demo01PrintArray { public static void main(String[] args) { int[] array = { 10, 20, 30, 40, 50, 60 }; // 要求打印格式为:[10, 20, 30, 40, 50] // 使用面向过程,每一个步骤细节都要亲力亲为。 System.out.print("["); for (int i = 0; i < array.length; i++) { if (i == array.length - 1) { // 如果是最后一个元素 System.out.println(array[i] + "]"); } else { // 如果不是最后一个元素 System.out.print(array[i] + ", "); } } System.out.println("=============="); // 使用面向对象 // 找一个JDK给我们提供好的Arrays类, // 其中有一个toString方法,直接就能把数组变成想要的格式的字符串 System.out.println(Arrays.toString(array)); } }
2 类和对象
什么是类
- 类:是一组相关属性和行为的集合。可以看成是一类事物的模板,使用事物的属性特征和行为特征来描述该类事物。
现实中,描述一类事物:
- 属性:就是该事物的状态信息。
- 行为:就是该事物能够做什么。
- 举例:小猫。 属性:名字、体重、年龄、颜色。 行为:走、跑、叫。
什么是对象
对象:是一类事物的具体体现。对象是类的一个实例,必然具备该类事物的属性和行为。
现实中,一类事物的一个实例:一只小猫。
举例:一只小猫。 属性:tom、5kg、2 years、yellow。 行为:溜墙根走、蹦跶的跑、喵喵叫。
类与对象的关系
类是对一类事物的描述,是抽象的。 对象是一类事物的实例,是具体的。 类是对象的模板,对象是类的实体。
例如:手机设计图是类(抽象的),真正的手机是对象(具体的)。
3 类的定义
成员变量:对应事物的属性 成员方法:对应事物的行为
类的定义格式
public class ClassName { //成员变量 String name; int age; //成员方法 //学习的方法 public void study() { System.out.println("好好学习,天天向上"); } //吃饭的方法 public void eat() { System.out.println("学习饿了要吃饭"); } } }
- 成员变量:和以前定义变量几乎是一样的。只不过位置发生了改变。在类中,方法外。
- 成员方法:和以前定义方法几乎是一样的。只不过把static去掉。
4 对象的使用
通常情况下,一个类并不能直接使用,需要根据类创建一个对象,才能使用。
- 导包:也就是指出需要使用的类,在什么位置。
import 包名称.类名称;
import cn.itcast.day06.demo01.Student;
对于和当前类属于同一个包的情况,可以省略导包语句不写。 - 创建,格式:
类名称 对象名 = new 类名称();
Student stu = new Student(); - 使用,分为两种情况:
使用成员变量:对象名.成员变量名
使用成员方法:对象名.成员方法名(参数)
(也就是,想用谁,就用对象名点儿谁。)
注意事项:如果成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样。
public class Demo02Student { public static void main(String[] args) { // 1. 导包。 // 我需要使用的Student类,和我自己Demo02Student位于同一个包下,所以省略导包语句不写 // 2. 创建,格式: // 类名称 对象名 = new 类名称(); // 根据Student类,创建了一个名为stu的对象 Student stu = new Student(); // 3. 使用其中的成员变量,格式: // 对象名.成员变量名 System.out.println(stu.name); // null System.out.println(stu.age); // 0 System.out.println("============="); // 改变对象当中的成员变量数值内容 // 将右侧的字符串,赋值交给stu对象当中的name成员变量 stu.name = "赵丽颖"; stu.age = 18; System.out.println(stu.name); // 赵丽颖 System.out.println(stu.age); // 18 System.out.println("============="); // 4. 使用对象的成员方法,格式: // 对象名.成员方法名() stu.eat(); stu.study(); } }
5 练习:手机类
定义一个类,用来模拟“手机”事物。
属性:品牌、价格、颜色
行为:打电话、发短信
对应到类当中:
成员变量(属性):
String brand; // 品牌
double price; // 价格
String color; // 颜色
成员方法(行为):
public void call(String who) {} // 打电话
public void sendMessage() {} // 群发短信
public class Phone { // 成员变量 String brand; // 品牌 double price; // 价格 String color; // 颜色 // 成员方法 public void call(String who) { System.out.println("给" + who + "打电话"); } public void sendMessage() { System.out.println("群发短信"); } }
public class Demo01PhoneOne { public static void main(String[] args) { // 根据Phone类,创建一个名为one的对象 // 格式:类名称 对象名 = new 类名称(); Phone one = new Phone(); System.out.println(one.brand); // null System.out.println(one.price); // 0.0 System.out.println(one.color); // null System.out.println("========="); one.brand = "苹果"; one.price = 8388.0; one.color = "黑色"; System.out.println(one.brand); // 苹果 System.out.println(one.price); // 8388.0 System.out.println(one.color); // 黑色 System.out.println("========="); one.call("乔布斯"); // 给乔布斯打电话 one.sendMessage(); // 群发短信 } }
6 一个对象的内存图
7 两个对象使用同一个方法的内存
public class Demo02PhoneTwo { public static void main(String[] args) { Phone one = new Phone(); System.out.println(one.brand); // null System.out.println(one.price); // 0.0 System.out.println(one.color); // null System.out.println("========="); one.brand = "苹果"; one.price = 8388.0; one.color = "黑色"; System.out.println(one.brand); // 苹果 System.out.println(one.price); // 8388.0 System.out.println(one.color); // 黑色 System.out.println("========="); one.call("乔布斯"); // 给乔布斯打电话 one.sendMessage(); // 群发短信 System.out.println("========="); Phone two = new Phone(); System.out.println(two.brand); // null System.out.println(two.price); // 0.0 System.out.println(two.color); // null System.out.println("========="); two.brand = "三星"; two.price = 5999.0; two.color = "蓝色"; System.out.println(two.brand); // 三星 System.out.println(two.price); // 5999.0 System.out.println(two.color); // 蓝色 System.out.println("========="); two.call("欧巴"); // 给欧巴打电话 two.sendMessage(); // 群发短信 } }
内存图
8 两个引用指向同一个对象的内存
public class Demo03PhoneSame { public static void main(String[] args) { Phone one = new Phone(); System.out.println(one.brand); // null System.out.println(one.price); // 0.0 System.out.println(one.color); // null System.out.println("========="); one.brand = "苹果"; one.price = 8388.0; one.color = "黑色"; System.out.println(one.brand); // 苹果 System.out.println(one.price); // 8388.0 System.out.println(one.color); // 黑色 System.out.println("========="); one.call("乔布斯"); // 给乔布斯打电话 one.sendMessage(); // 群发短信 System.out.println("========="); // 将one当中保存的对象地址值赋值给two Phone two = one; System.out.println(two.brand); // 苹果 System.out.println(two.price); // 8388.0 System.out.println(two.color); // 黑色 System.out.println("========="); two.brand = "三星"; two.price = 5999.0; two.color = "蓝色"; System.out.println(two.brand); // 三星 System.out.println(two.price); // 5999.0 System.out.println(two.color); // 蓝色 System.out.println("========="); two.call("欧巴"); // 给欧巴打电话 two.sendMessage(); // 群发短信 } }
内存图
9 使用对象类型作为方法的参数
//定义一个名为Phone的类 public class Phone { // 成员变量 String brand; // 品牌 double price; // 价格 String color; // 颜色 // 成员方法 public void call(String who) { System.out.println("给" + who + "打电话"); } public void sendMessage() { System.out.println("群发短信"); } }
public class Demo04PhoneParam { public static void main(String[] args) { Phone one = new Phone(); //根据Phone类,创建一个名为one的对象 // 格式:类名称 对象名 = new 类名称(); one.brand = "苹果"; one.price = 8388.0; one.color = "土豪金"; method(one); // 传递进去的参数其实就是地址值 } public static void method(Phone param) { //定义方法的完整格式: 修饰符 返回值类型 方法名称(参数类型 参数名称, …) {方法体 return 返回值;} System.out.println(param.brand); // 苹果 System.out.println(param.price); // 8388.0 System.out.println(param.color); // 土豪金 } }
内存图
10 使用对象类型作为方法的返回值
public class Demo05PhoneReturn { public static void main(String[] args) { Phone two = getPhone(); System.out.println(two.brand); // 苹果 System.out.println(two.price); // 8388.0 System.out.println(two.color); // 玫瑰金 } public static Phone getPhone() { //方法返回值类型Phone,方法名getPhone Phone one = new Phone(); //创建对象one one.brand = "苹果"; one.price = 8388.0; one.color = "玫瑰金"; return one; } }
内存图
11 成员变量和局部变量的区别
局部变量和成员变量
- 定义的位置不一样【重点】
局部变量:在方法的内部
成员变量:在方法的外部,直接写在类当中 - 作用范围不一样【重点】
局部变量:只有方法当中才可以使用,出了方法就不能再用
成员变量:整个类全都可以通用。 - 默认值不一样【重点】
局部变量:没有默认值,如果要想使用,必须手动进行赋值
成员变量:如果没有赋值,会有默认值,规则和数组一样 - 内存的位置不一样(了解)
局部变量:位于栈内存
成员变量:位于堆内存 - 生命周期不一样(了解)
局部变量:随着方法进栈而诞生,随着方法出栈而消失
成员变量:随着对象创建而诞生,随着对象被垃圾回收而消失
public class Demo01VariableDifference { String name; // 成员变量 public void methodA() { int num = 20; // 局部变量 System.out.println(num); System.out.println(name); } public void methodB(int param) { // 方法的参数就是局部变量 // 参数在方法调用的时候,必然会被赋值的。 System.out.println(param); int age; // 局部变量 // System.out.println(age); // 没赋值不能用 // System.out.println(num); // 错误写法! System.out.println(name); } }
12 面向对象三大特征之封装性
面向对象三大特征:封装、继承、多态。
封装性在Java当中的体现:
- 方法就是一种封装
- 关键字private也是一种封装
封装就是将一些细节信息隐藏起来,对于外界不可见。
public class Demo02Method { public static void main(String[] args) { int[] array = {5, 15, 25, 20, 100}; int max = getMax(array); System.out.println("最大值:" + max); } // 给我一个数组,我还给你一个最大值 public static int getMax(int[] array) { int max = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] > max) { max = array[i]; } } return max; } }
13 private关键字的作用及使用
问题描述:定义Person的年龄时,无法阻止不合理的数值被设置进来。
解决方案:用private关键字将需要保护的成员变量进行修饰。
一旦使用了private进行修饰,那么本类当中仍然可以随意访问。
但是!超出了本类范围之外就不能再直接访问了。
间接访问private成员变量,就是定义一对儿Getter/Setter方法
必须叫setXxx或者是getXxx命名规则。
对于Getter来说,不能有参数,返回值类型和成员变量对应;
对于Setter来说,不能有返回值,参数类型和成员变量对应。
public class Person { //定义Person的类 String name; // 姓名 private int age; // 年龄 public void show() { System.out.println("我叫:" + name + ",年龄:" + age); } // 这个成员方法,专门用于向age设置数据,set是往里放 public void setAge(int num) { if (num < 100 && num >= 9) { // 如果是合理情况 age = num; } else { System.out.println("数据不合理!"); } } // 这个成员方法,专门私语获取age的数据,get是往外拿 public int getAge() { return age; } }
public class Demo03Person { public static void main(String[] args) { Person person = new Person(); person.show(); person.name = "赵丽颖"; // person.age = -20; // 直接访问private内容,错误写法! person.setAge(20); // 间接访问 person.show(); } }
14 练习:使用private关键字定义
特例:对于基本类型当中的boolean值,Getter方法一定要写成isXxx的形式,而setXxx规则不变。
public class Student { private String name; // 姓名 private int age; // 年龄 private boolean male; // 是不是爷们儿 public void setMale(boolean b) { male = b; } public boolean isMale() { return male; } public void setName(String str) { name = str; } public String getName() { return name; } public void setAge(int num) { age = num; } public int getAge() { return age; } }
public class Demo04Student { public static void main(String[] args) { Student stu = new Student(); stu.setName("鹿晗"); stu.setAge(20); stu.setMale(true); System.out.println("姓名:" + stu.getName()); System.out.println("年龄:" + stu.getAge()); System.out.println("是不是爷们儿:" + stu.isMale()); } }
15 this关键字的作用
使用this关键字解决局部变量与成员变量重名的问题
当方法的局部变量和类的成员变量重名的时候,根据“就近原则”,优先使用局部变量。
如果需要访问本类当中的成员变量,需要使用格式:
this.成员变量名
“通过谁调用的方法,谁就是this。”
public class Person { String name; // 我自己的名字 // 参数name是对方的名字 // 成员变量name是自己的名字 public void sayHello(String name) { System.out.println(name + ",你好。我是" + this.name); System.out.println(this); } }
public class Demo01Person { public static void main(String[] args) { Person person = new Person(); // 设置我自己的名字 person.name = "王健林"; person.sayHello("王思聪"); System.out.println(person); // 地址值 } }
16 构造方法
构造方法是专门用来创建对象的方法,当我们通过关键字new来创建对象时,其实就是在调用构造方法。
格式:
public 类名称(参数类型 参数名称) {
方法体
}
注意事项:
- 构造方法的名称必须和所在的类名称完全一样,就连大小写也要一样
- 构造方法不要写返回值类型,连void都不写
- 构造方法不能return一个具体的返回值
- 如果没有编写任何构造方法,那么编译器将会默认赠送一个构造方法,没有参数、方法体什么事情都不做。
public Student() {} - 一旦编写了至少一个构造方法,那么编译器将不再赠送。
- 构造方法也是可以进行重载的。
重载:方法名称相同,参数列表不同。
public class Student { // 成员变量 private String name; private int age; // 无参数的构造方法 public Student() { System.out.println("无参构造方法执行啦!"); } // 全参数的构造方法 public Student(String name, int age) { System.out.println("全参构造方法执行啦!"); this.name = name; this.age = age; } // Getter Setter public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } }
public class Demo02Student { public static void main(String[] args) { Student stu1 = new Student(); // 无参构造 System.out.println("============"); Student stu2 = new Student("赵丽颖", 20); // 全参构造 System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge()); // 如果需要改变对象当中的成员变量数据内容,仍然还需要使用setXxx方法 stu2.setAge(21); // 改变年龄 System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge()); } }
17 定义一个标准的类
一个标准的类通常要拥有下面四个组成部分:
- 所有的成员变量都要使用private关键字修饰
- 为每一个成员变量编写一对儿Getter/Setter方法
- 编写一个无参数的构造方法
- 编写一个全参数的构造方法
这样标准的类也叫做Java Bean
自动生成Getter、Setter:点击Code—generate—Getter and Setter
自动生成无参数构造方法:Code—generate—constructor—select None
自动生成全参数构造方法:Code—generate—constructor—全选—OK
public class Student { private String name; // 姓名 private int age; // 年龄 public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } 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 class Demo01Student { public static void main(String[] args) { Student stu1 = new Student(); stu1.setName("迪丽热巴"); stu1.setAge(20); System.out.println("姓名:" + stu1.getName() + ",年龄:" + stu1.getAge()); System.out.println("================="); Student stu2 = new Student("古力娜扎", 21); System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge()); stu2.setAge(22); System.out.println("姓名:" + stu2.getName() + ",年龄:" + stu2.getAge()); } }
- 7 面向对象(成员变量和局部变量的区别,类作为形式参数的问题,匿名对象,封装,private关键字,this关键字,构造方法,类的初始化过程,static关键字)
- java的方法重载,面向对象的概念,编写类以及创建对象,成员变量与局部变量的区别,构造方法以及构造方法的重载,空指针异常,封装,this关键字,参数传递,static关键字,继承的概念及相关代码
- 黑马程序员—Java面向对象(类和对象、封装、构造方法、this关键字、static关键字)
- 匿名对象、封装的概述;关键字(private,this,static)的概述和应用;成员变量和静态变量的区别;如何使用JDK提供的帮助文档;Math类的随机数使用功能;构造方法的概述和格式
- Java中封装和this()调用构造方法以及对象作为参数使用知识点
- 面向对象,类和对象,封装性,private关键字,this关键字,构造方法
- Java基础第7天+成员变量和局部变量的区别、匿名对象、封装、private关键字、this关键字、构造方法、static关键字...
- 成员变量和局部变量的区别、方法的形参为类的情况及匿名对象、封装(private关键字)、this关键字、构造方法、static关键字
- 6.1面向对象(介绍,类与对象,封装,this关键字,构造方法,static关键字)
- Java从入门到放弃06---面向对象/成员变量和局部变量的区别/this关键字/匿名对象/封装(private关键字)
- C++第十章__类和对象定义的基础知识__类的构造函数和析构函数__const成员函数__书中的构造函数和析构函数的总结__this指针 & 类对象作为类方法的参数 & 返回值为类对象的引用 __对象...
- 4.构造方法与重载:定义一个网络用户类,要处理的信息有用户 ID、用户密码、 email 地址。在建立类的实例时把以上三个信息都作为构造函数的参数输入, 其中用户 ID 和用户密码时必须缺省时 ema
- this关键字、static静态修饰符、构造方法、成员方法、主函数main的解释、一个标准类的定义规则
- 当类中的方法全部都是 static 关键字修饰时 ,它的构造方法最好作为 private 私有化,理由是方法全是 static, 不知道的人会去new对象去调用,需要调用构造方法。 但 static的方法直接用类名调用就行!
- Java第7次作业:造人类(用private封装,用static关键字自己造重载输出方法)什么是面向对象程序设计?什么是类和对象?什么是无参有参构造方法 ?什么是封装?
- 阶段1 语言基础+高级_1-2 -面向对象和封装_15练习使用private关键字定义
- Java基础加强重温_01: 基础回顾(类、对象、类成分、封装、构造方法、this关键字)、static关键字(修饰成员变量,成员方法)、继承( )、抽象类(abstract)、模板设计模式
- 09-面向对象之类的定义、private、this、构造方法、get方法、set方法、匿名对象
- 黑马程序员_Java基础_面向对象(概述、类与对象关系、成员变量、封装private、构造函数和构造代码块、this关键字)
- 面向对象 封装 private关键字 构造方法