【类与对象、封装】
面向对象思想的概述
面向过程:当需要实现一个功能的时候,每一个具体的步骤都要亲历亲为,详细处理每一个细节;
面向过程:当需要实现一个功能的时候,不关心具体步骤,而是找一个已经具有该功能的人,来帮我实现。
import java.util.Arrays;
public class PrintArray {
public static void main(String[] args) {
int[] arrayA = {10, 20, 30, 40, 50};
// 要求打印格式为:[10, 20, 30, 40, 50]
// 使用面向过程,每一个步骤细节都要亲力亲为:
System.out.print("[");
for (int i = 0; i < arrayA.length; i++) {
if (i == arrayA.length-1){
System.out.println(arrayA[i]+"]");
}else{
System.out.print(arrayA[i]+", ");
}
}
System.out.println("------------------");
// 使用面向对象,找一个JDK给我们提供好的Arrays类
// 其中有一个toString方法,直接就能把数组变成想要的格式的字符串
System.out.println(Arrays.toString(arrayA));
}
}
特点:
面向对象思想是一种更符合我们思维习惯的思想,它可以将复杂的事情简单化,并将我们从执行者变成指挥者。
面向对象语言中,包含了三大特征:封装性、继承性、多态性。
类与对象
类和对象的关系
什么是类
- 类是一种相关属性和行为的集合,可以看成是一种事物的模板,使用事物的属性特征和行为特征来描述该类事物。
现实生活中,描述一类事物:
- **属性:**就是该事物的状态信息。
- **行为:**就是该事物能够做什么。
举例:小猫,
属性:名字、体重、年龄、颜色…
行为:走、跑、叫…
什么是对象
- **对象:**是一类事物的具体体现。对象是类的一个实例,必然具备该事物的属性和行为。
类和对象的关系
- 类是对一类事物的描述,是抽象的;
- 对象是一类事物的实例,是具体的;
- 类是对象的模板,对象是类的实体。
类的定义
定义一个类,用来模拟“学生”这个事物,其中就有两个组合部分:
属性(是什么):姓名、年龄;
行为(能做什么):吃饭、睡觉、学习。
对应到Java的类当中:
public class Student {
//成员变量(属性):
String name;//姓名
int age;//年龄
//成员方法(行为):
public void eat(){
System.out.println("吃饭饭!");
}//吃饭
public void sleep(){
System.out.println("睡觉觉!");
}//睡觉
public void study(){
System.out.println("学习!");
}//学习
}
注意事项:
1.成员变量是直接定义在类当中,在方法外边;
2.成员方法定义不要写static关键字。
对象的创建及其使用
通常情况下,一个类并不能直接使用,需要根据类创建一个对象,才能使用。
- 1.导包:也就是指出需要使用的类,在什么位置。
- import 包名称.类名称;
例:import com.unique.day06.demo01.Student; - 对于和当前类属于同一个包的情况,可以省略导包语句不写。
- import 包名称.类名称;
- 2.创建,格式:
- 类名称 对象名称 = new 类名称();
- 例:Student stu = new Student();
- 3.使用。分两种情况:
- 使用成员变量:对象名.成员变量名;
- 使用成员方法:对象名.成员方法名(参数);
- (也就是,想用谁,就用对象名.谁)
public class StudentInstance {
public static void main(String[] args) {
// 1.导包
// 需要使用的Student类,和StudentInstance位于同一个包下,所以省略导包语句不写。
// 2.根据Student类,创建一个名为stu的对象
Student stu = new Student();
// 3.使用其中的成员变量,格式:
// 对象名.成员变量名;
System.out.println(stu.age);
System.out.println(stu.name);
}
注意事项:
如果成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样。
两个对象使用同一个方法的内存
定义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 PhoneTwo {
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 = "xiaomi";
one.price = 3999.0;
one.color = "black";
System.out.println(one.brand);//xiaomi
System.out.println(one.price);//3999.0
System.out.println(one.color);//black
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 = "oneplus";
two.price = 3500.0;
two.color = "red";
System.out.println(two.brand);//oneplus
System.out.println(two.price);//3500.0
System.out.println(two.color);//red
System.out.println("------------------");
two.call("刘作虎");//给刘作虎打电话
two.sendMessage();//群发短信
}
}
两个引用指向同一个对象空间
public class PhoneSame {
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 = "xiaomi";
one.price = 3999.0;
one.color = "black";
System.out.println(one.brand);//xiaomi
System.out.println(one.price);//3999.0
System.out.println(one.color);//black
System.out.println("------------------");
one.call("雷布斯");//给雷布斯打电话
one.sendMessage();//群发短信
System.out.println("------------------");
Phone two = one;
System.out.println(two.brand);//xiaomi
System.out.println(two.price);//3999.0
System.out.println(two.color);//black
System.out.println("------------------");
two.brand = "oneplus";
two.price = 3500.0;
two.color = "red";
System.out.println(two.brand);//oneplus
System.out.println(two.price);//3500.0
System.out.println(two.color);//red
System.out.println("------------------");
two.call("刘作虎");//给刘作虎打电话
two.sendMessage();//群发短信
}
}
使用对象类型作为方法的参数
public class PhoneParam {
public static void main(String[] args) {
Phone one = new Phone();
one.brand = "xiaomi";
one.price = 2000.0;
one.color = "white";
method(one,"雷布斯");
// xiaomi
// 2000.0
// white
// 给雷布斯打电话
// 群发短信
}
public static void method(Phone param,String a){
System.out.println(param.brand);
System.out.println(param.price);
System.out.println(param.color);
param.call(a);
param.sendMessage();
}
}
**注意:**当一个对象作为参数,传递到方法当中时:实际上传递进去的是对象的地址值。
使用对象类型作为方法的返回值
public class PhoneReturn {
public static void main(String[] args) {
Phone xiaomi = getPhone("xiaomi", 3999.0, "red");
System.out.println(xiaomi.brand);
System.out.println(xiaomi.price);
System.out.println(xiaomi.color);
xiaomi.call("雷布斯");
/*xiaomi
3999.0
red
给雷布斯打电话*/
}
public static Phone getPhone(String brand, double price, String color) {
Phone one = new Phone();
one.brand = brand;
one.price = price;
one.color = color;
return one;
}
}
**注意:**当使用一个对象类型作为方法的返回值时:返回值其实就是对象的地址值。
成员变量与局部变量的区别
- 1.定义的位置不一样【重点】
- 局部变量:在方法的内部
- 成员变量:在方法的外部,直接写在类当中
- 2.作用范围不一样【重点】
- 局部变量:只有方法当中才可以使用,出了方法就不能再用
- 成员变量:整个类全都可以通用
- 3.默认值不一样【重点】
- 局部变量:没有默认值,如果要想使用,必须手动赋值
- 成员变量:如果没有赋值,会有默认值,规则和数组一样
- 4.内存的位置不一样(了解)
- 局部变量:位置栈内存
- 成员变量:位于堆内存
- 生命周期不一样(了解)
- 局部变量:随着方法进栈而诞生,随着方法出栈而消失
- 成员变量:随着对象创建而诞生,随着对象被垃圾回收而消失
public class VariableDifference {
String name;//成员变量
public void methodA(){//成员方法
int num = 20;//局部变量
System.out.println(num);//20
System.out.println(name);//null
}
public void methodB(int param){//方法的参数就是局部变量
//参数在方法调用的时候,必然会被赋值;
System.out.println(param);
int age;//局部变量
// System.out.println(age);//Variable 'age' might not have been initialized
// System.out.println(num);//局部变量在方法外不能用
System.out.println(name);//null
}
}
面向对象三大特征之封装性
面向对象三大特征:封装、继承、多态。
封装性在Java中的体现:
1.方法就是一种封装;
2.关键字private也是一种封装
封装就是将一些细节信息隐藏起来,对于外界不可见:
public class Method {
public static void main(String[] args) {
int[] arrayA = {10, 20, 40};
int max = getMax(arrayA);
System.out.println("最大值为" + max);
}
//给我一个数组,我返回给你一个最大值
public static int getMax(int[] array) {...}
}
private关键字的作用及使用
问题描述:定义Person类的年龄的时候,无法阻止不合理的数值被设置进来。
解决方案:用privale关键字将需要保护的成员变量进行修饰。
一旦使用private进行修饰,那么本类中仍可以随意访问。但是!超出了本类范围之外就不能再直接访问了。
间接访问private成员变量,就是定义一对Getter/Setter方法。
必须交setXxx或者是getXxx的命名规则:
对于Getter来说,不能有参数,返回值类型和成员变量对应;
对于Setter来说,不能有返回值,参数类型和成员变量对应;
注意:对于基本数据类型当中的boolean值,Getter方法一定要写成isXxx的形式,而setXxx规则不变。
public class Person {
String name;
private int age;//用private对 age进行修饰,限制访问
public void setAge(int num) {//这个成员方法,专门用于向age设置数据
if (num < 120 && num >= 0) {
age = num;
} else {
System.out.println("输入有误!");
}
}
public int getAge() {//这个成员方法,专门用于获取age数据
return age;
}
public void show() {
System.out.println("姓名:" + name + "年龄:" + age);
}
}
public class PersonCall {
public static void main(String[] args) {
Person person = new Person();
person.name = "L";
person.setAge(-29);//输入有误!
person.show();//姓名:L年龄:0
person.setAge(30);
person.show();//姓名:L年龄:30
}
}
this关键字的作用
当方法的局部变量和类的成员变量重名的时候,根据“就近原则”,有限使用局部变量;
如果需要访问本类当中的成员变量,需要使用格式:
this.成员变量名
“通过谁调用的方法,谁就是this"。
public class Person {
String name;
public void sayHello(String name){
System.out.println(name + ",你好。我是"+this.name);
System.out.println(this);
}
}
public class PersonCall {
public static void main(String[] args) {
Person person = new Person();
person.name = "王健林";
person.sayHello("王思聪");
// 王思聪,你好。我是王健林
// com.unique.day6.demo02.Person@1b6d3586
System.out.println(person);
// com.unique.day6.demo02.Person@1b6d3586
}
}