新手小白学JAVA 面向对象 类 对象 封装

Posted 2021-05-09 程序媛 泡泡

面向对象概念

在学习面向对象之前，我们可以先了解一下面向过程。面向过程是一种思想，意思是我们要做任何事，都需要亲力亲为，强调的是过程。
面向对象也是一种编程思想，相对于面向过程，我们可以由原来问题的执行者变为指挥者，进而把生活中很多复杂的问题变得简单化。

面向过程强调的是过程,比如,把大象装冰箱,一共分3步:
第1步：打开冰箱门
第2步：把大象放进去
第3步：关上冰箱门
而面向对象强调的是结果,比如:
什么样的冰箱?什么样的大象?谁负责把大象装进去?
有没有发现，如果是面向对象的话，干这件事的主体并不是你自己，你变成了一个指挥者？

再比如，衣服脏了，我们可以让女盆友帮忙洗，不需要关注中间过程是怎么洗的，就可以拿到干净的衣服，当然，这首先需要有一个对象（加油哦）~

还有，当我们想吃一道菜,其实并不需考虑这道菜是怎么做的,怎么送达的，只需点菜即可.传菜和做菜都有具体的对象来完成具体的功能.我们不需要关注实现的过程,只需要关注结果就好。

这就是我们所说的面向对象的编程思想（OOP，Object Oriented Programming）

如果面试官问什么是面向对象？你答万物皆对象！额，不建议这样做哈，因为我们还没到大佬的这个高度，还是最好举例。
就像是你说 : 空即是色 色即是空…信你个鬼鬼

2 面向对象的三大特征

1. 封装: 把相关的数据封装成一个“类”组件
2. 继承: 是子类自动共享父类属性和方法，这是类之间的一种关系
3. 多态: 增强软件的灵活性和重用性

3 类和对象

3.1 类

1. Java语言最基本单位就是类，类似于类型。
2. 类是一类事物的抽象。
3. 可以理解为模板或者设计图纸。

3.2 对象

每个对象具有三个特点：对象的状态，对象的行为和对象的标识。

1. 对象的状态用来描述对象的基本特征。
2. 对象的行为用来描述对象的功能。
3. 对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来。
4. 类是一类事物的抽象，对象是具体的实现。

3.3 类和对象的关系

1. 计算机语言来怎么描述现实世界中的事物的? 属性 + 行为
2. 那怎么通过java语言来描述呢?
   我们可以通过类来描述一类事物,用成员变量描述事物的属性,用方法描述事物的行为.

3.4 练习：类的创建使用

在编写代码之前,我们需要分析下需求:
比如我们要把手机这一类事物抽象成代码：
那么这个事物的类型就是"手机",可以用类来描述.
类中包含的就是手机抽取出来的共性的属性与功能.

手机的属性：颜色，尺寸，品牌，价格
手机的功能功能：打电话，发短信，听音乐

对象：除此之外,我们还可以创建对象,就相当于是照着图纸制造出来的一个个的手机,比如1号手机对象，包含特有的成员变量和方法
我们通过class关键字创建类，通过new关键字创建对象。
接下来我们开始编码吧!
创建包: cn.tedu.oop
创建类: TestCreateClass.java

package cn.tedu.oop;
/**本类用来练习面向对象
 * 分析手机事物:--通过类来描述
 * 属性:品牌 价格 尺寸 颜色
 * 功能:打电话 发短信 听直播
 * */
//在一个java文件中可以写多个class,但是被public修饰的只能有一个,而且这个类的名字就是文件名
public class TestCreateClass {
	public static void main(String[] args) {
		//2.在main()中通过new关键字来创建对应类的对象
		Phone p = new Phone();
		//3.通过.来完成对象功能的调用
		p.call();
		p.message();
		p.learn();
		//4.通过.来查看对象的属性值
		System.out.println(p.brand);
		System.out.println(p.price);
		System.out.println(p.size);
		System.out.println(p.color);
		
	}
}
//1.通过class关键字创建手机类--用来描述手机这一类事物--特征+行为
//类是一类事物的抽象,只抽象的规定这一类事物的特征和行为
class Phone{
	//特征(属性)--类的成员变量来描述--位置:类里方法外
	String brand;//品牌
	double price;//价格
	double size;//尺寸
	String color;//颜色
	
	//行为(功能)--类的方法来描述--修饰符 返回值类型 方法名(参数列表){方法体}
	public void call() {
		System.out.println("正在打电话");
	}
	public void message() {
		System.out.println("正在发短信");
	}
	public void learn() {
		System.out.println("正在看直播");
	}
}

3.5 对象在内存中的存储

Java把内存分成5大区域，我们重点关注栈和堆。

1. 一般来讲局部变量存在栈中，方法执行完毕内存就被释放
2. 对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
3. 每个堆内存的元素都有地址值
4. 对象中的属性都是有默认值的
   TIPS: 栈与队列指的是一种数据的结构。
   栈：先进后出（FILO – First In Last Out）
   队列：先进先出（FIFO – First In First Out）
   
   
   

3.6 练习2：创建多个对象

package cn.tedu.oop;
/**本类用来练习面向对象
 * 分析手机事物:--通过类来描述
 * 属性:品牌 价格 尺寸 颜色
 * 功能:打电话 发短信 听直播
 * */
//在一个java文件中可以写多个class,但是被public修饰的只能有一个,而且这个类的名字就是文件名
public class TestCreateClass {
	public static void main(String[] args) {
		//2.在main()中通过new关键字来创建对应类的对象
		Phone p = new Phone();
		//3.通过.来完成对象功能的调用
		p.call();
		p.message();
		p.learn();
		//4.通过.来查看对象的属性值
		System.out.println(p.brand);
		System.out.println(p.price);
		System.out.println(p.size);
		System.out.println(p.color);
		
		//5.创建第二个对象
		Phone p2 = new Phone();
		
		//5.1调用模板里的功能
		p2.call();
		p2.message();
		p2.learn();
		
		//5.2给对象的属性设置值
		p2.brand = "HUAWEI";
		p2.price = 8888.88;
		p2.size = 5.6;
		p2.color = "中国红";
		
		//5.3通过.来查看对象的属性值
		System.out.println(p2.brand);
		System.out.println(p2.price);
		System.out.println(p2.size);
		System.out.println(p2.color);
		
	}
}
//1.通过class关键字创建手机类--用来描述手机这一类事物--特征+行为
//类是一类事物的抽象,只抽象的规定这一类事物的特征和行为
class Phone{
	//特征(属性)--类的成员变量来描述--位置:类里方法外
	String brand;//品牌
	double price;//价格
	double size;//尺寸
	String color;//颜色
	
	//行为(功能)--类的方法来描述--修饰符 返回值类型 方法名(参数列表){方法体}
	public void call() {
		System.out.println("正在打电话");
	}
	public void message() {
		System.out.println("正在发短信");
	}
	public void learn() {
		System.out.println("正在看直播");
	}
}

p2.brand = “HUAWEI”;
就是先到栈内存中找到p2中保存的唯一的地址值
然后根据地址值找到对应的Phone对象,并对其对应的属性值进行修改
p2.eat();
也是先到栈内存中找到p2中保存的唯一的地址值
然后根据地址值找到对应Phone对象,执行Phone对象的eat()方法

4 封装

4.1 概述

封装是隐藏对象的属性和实现细节,仅仅对外提供公共的访问方式,比如类和方法
好处:

1. 提高安全性
2. 提高重用性

4.2 private关键字

是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问

4.3 练习：封装学生案例

创建包: cn.tedu.oop
创建类: TestPrivate.java

package cn.tedu.oop;
/**本类用于测试封装*/
public class TestPrivate 函数main
	public static void main(String[] args) {
		//5.创建学生类对象--通过new关键字创建学生类对象
		Student s = new Student();
		//6.初步测试Student类对象s
		System.out.println(s.name);//可以通过"."来调用s对象的name属性,查看它的值
		s.study();//可以通过"."来调用s对象的study()
		//7.给s对象的属性赋值
		s.name = "程序猿";
		s.sno = 666;
		//s.subject = "Java培优";
		//8.查看赋值后的属性值
		System.out.println(s.name);
		System.out.println(s.sno);
		//System.out.println(s.subject);
		
		//10.通过Student类中提供 的公共的subject属性的设置与访问方法来给subject属性赋值并查看
		s.setSubject("JavaCGB");
		System.out.println(s.getSubject());
		
		//eat();
		s.study();
	}
}
//1.通过class关键字创建学生类--用来描述学生这一类型--属性+行为
/***
 * 封装:通过private关键字(权限修饰符)来修饰成员变量/成员方法
 * 被修饰的成员就实现了私有化,访问权限只能在本类中访问
 */
class Student{
	//2.定义属性--成员变量
	String name;//姓名
	int sno;//学号
	//9.对成员变量进行封装
	private String subject;//科目
	/**对外提供公共的属性值设置方式*/
	public void setSubject(String s) {
		subject = s;
	}
	/**对外提供公共的属性值查看方式*/
	public String getSubject() {
		return subject;
	}
	//3.定义行为--方法
	public void study() {
		System.out.println("正在学习JAVA");
		/**我们可以在公共的方法里调用私有方法*/
		eat();
	}
	//11.封装方法
	private void eat() {
		System.out.println("干饭人 干饭魂");
	}
}

TIPS:如何封装?封装后的资源如何访问?
我们可以使用private关键字来封装成员变量与方法
如何访问私有资源?
关于成员变量:
setXxx – 对外提供公共的设置值方式
getXxx – 对外提供公共的获取值方式
关于成员方法:
把私有方法放在公共方法里供外界调用即可

5 拓展

5.1 练习:创建Teacher类进行OOP综合练习之封装

创建包: cn.tedu.oop
创建类: TestTeacher.java

package cn.tedu.oop;
/**本类用于进行OOP综合练习*/
public class TestTeacher {
	public static void main(String[] args) {
		Teacher t = new Teacher();//6.调用无参构造创建对象
		//7.由于private将Teacher类中的属性都封装了,外界无法直接使用,所以需要使用set()/get()
		//t.name;//报错:The field Teacher.name is not visible
		System.out.println(t.getName());//如果没有设置值或者是设置没有成功，获取的是默认值null
		t.setName("鲁智深");
		System.out.println(t.getName());
		
		//8.直接调用全参构造来创建对象并且给对象的属性赋值
		Teacher t2 = new Teacher("李逵","壮汉",28,300);
		System.out.println(t2.getName()+t2.getAge()+t2.getGender()+t2.getSalary());
	}
}
//1.创建Teacher类
class Teacher{/**1.属性  2.get()/set() 3.构造方法*/
	//2.1提供属性
	//2.2对属性进行封装--通过private关键字进行封装
	private String name;
	private String gender;
	private int age;
	private double salary;
	
	/**如果什么构造方法都没有添加,默认会存在无参构造
	 * 我们创建了丰富的构造方法,是为了给外界提供创建本类对象的多种方式
	 * 如果自定了含参构造,默认的无参构造会被覆盖,注意手动添加哦
	 * */
	//3.添加无参构造方法
	public Teacher() {
		System.out.println("我是无参构造");
	}
	//4.添加全参构造方法
	public Teacher(String n,String g,int a,double s) {
		//5.在构造方法中为成员变量进行赋值
		name = n;//n是局部变量也就是用户调用此构造传入的参数,把参数赋值给成员变量name
		gender = g;
		age = a;
		salary = s;
		System.out.println("我是全参构造");
	}
	
	//2.3需要给外界提供公共的属性设置与访问方式
	//快捷方法:右键空白处-->Source-->Genreate Getters and Setters-->select All-->Generate生成即可
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
}

5.2 创建对象的流程

Person p = new Person();//短短这行代码发生了很多事情
1.把Person.class文件加载进内存
2.在栈内存中，开辟空间，存放引用变量p
3.在堆内存中，开辟空间，存放Person对象
4.对成员变量进行默认的初始化
5.对成员变量进行显示初始化
6.执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
7.堆内存完成
8.把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值

5.3 匿名对象

没有名字的对象，是对象的简化表示形式。
使用场景：
当被调用的对象只调用一次时（多次会创建多个对象浪费内存）
Demo d = new Demo();
d.sleep();
d.game();
//这个d就是对象的名字。
也可以写成：
new Demo().show();//创建了一个对象调方法
new Demo().game();//又创建了一个对象调方法