第二阶段-面向对象-day01

第二阶段-面向对象

面向对象-day01

今日学习内容：

• 软件的开发方式
• 成员变量和局部变量
• 类的定义和对象的创建
• 对象的操作
• 构造器
• 封装思想
• 访问权限修饰符
• JavaBean规范

今日学习目标：

• 了解什么是面向过程和面向对象
• 掌握变量的分类有哪些
• 记住成员变量的初始值
• 记住变量的作用域
• 记住变量的生命周期
• 必须掌握类的定义
• 必须掌握对象的创建和操作方法和字段
• 必须掌握构造器的定义和作用
• 理解封装思想的好处
• 必须掌握private和public两个访问权限修饰符
• 掌握JavaBean规范的四个要求

9.面向对象概述

9.1. 软件开发方式（了解）

9.1.1.面向过程（了解）

​ 一种较早的编程思想，顾名思义该思想是站在过程的角度思考问题，强调的是我该怎么去做。即功能的执行过程，即先干啥，后干啥。

​ 面向过程思想中函数是一等公民，每个函数负责完成某一个功能，用以接受输入数据，函数对输入数据进行处理，然后输出结果数据。

而每一个功能我们都使用函数（类似于方法）把这些步骤一步一步实现，使用的时候依次调用函数就可以了。

面向过程的设计思想，系统软件适应性差，可拓展性差，维护性低。

9.1.2.面向对象（了解）

​ 一种基于面向过程的新的编程思想，顾名思义该思想是站在对象的角度思考问题，我们把多个功能合理的放到不同对象里，强调的是我该让谁来做。

​ 面向对象最小的程序单元是类，必须先存在类的定义，再有对象，而具备某种功能的实体，称为对象。

举个例子，小明完成买菜，做菜，吃饭，洗完，写代码功能。

大家一起来看看有对象和没对象的区别：

​ 左图是没有对象的，右图是有对象的。区分面向过程的我该怎么做和面向对象的我该让谁来做的思想。

​ 面向过程和面向对象各有千秋，面向对象更符合我们常规的思维方式，稳定性好，可重用性强，易于开发大型软件产品，有良好的可维护性，它拥有三大特征：

• 封装（Encapsulation）
• 继承（Inheritance）
• 多态（Polymorphism）

​ 面向对象的学习，在基础班至少必须掌握知识点的定义和使用问题，思想是比较深远的，在大神班我们还会结合很多案例，去学习和巩固面向对象更多的精髓。

9.1.3.什么是抽象（了解）

​ 先来普及一个面向对象中非常重要的一个概念——抽象。

​ 所谓抽象，从特定的角度出发，从已经存在的多个事物中抽取我们所关注的特性、行为，从而产生一个新的事物的思维过程，是一种从复杂到简洁的思维方式。

​ 比如，根据大多数情况下女人穿裙子的特征，从关注穿着裙子和性别的关系上，有下图的抽象过程。

9.2. 成员变量和局部变量（掌握）

回忆变量的定义语法:

​ 数据类型 变量名 = 初始值;

9.2.1. 变量的分类（能区分）

​ 根据变量定义位置的不同，分成两大类:

• 成员变量：直接定义在类中，方法外面。又称之为字段（Field），不要称之为属性（错误），后讲
• 局部变量：除了成员变量，其他都是局部变量，具体存在于三个地方
  • 方法内
  • 方法的形参
  • 代码块中（一对花括号）

以下代码中，哪些是成员变量哪些是局部变量？

public class App {
	
	String name;
	int age;		
	
	void doWork() {
		int[] arr = new int[] {1,3,5};
		for (int index = 0; index < arr.length; index++) {
			int ele = arr[index];
			System.out.println(ele);
		}
	}
	
	int getSum(int a,int b) {
		int c = a + b;
		return c;
	}
}

你猜对了吗？

9.2.2.变量的初始值（要记住）

变量的初始化表示在内存中开辟存储空间，只有初始化之后，才能使用。

• 成员变量：默认是有初始值的，不同类型的初始值，如下图
• 局部变量：没有初始值，所以必须手动先初始化才能使用

9.2.3.变量的作用域（要记住）

变量根据定义的位置不同，也决定了各自的作用域是不同的，关键看变量所在的那对花括号。

• 成员变量：在所定义的类中都有效
• 局部变量：从开始定义的位置开始，只能在自己所在的花括号内有效

9.2.4.变量的生命周期（要记住）

变量的生命周期，表示变量在内存在能存活多久。

• 成员变量：存储在堆内存中，随着对象的销毁而销毁
• 局部变量：存储在栈内存中，随着所定义方法的调用结束而销毁
  • 局部变量存储在方法中，每次调用方法都会在栈空间开辟一块内存空间——栈帧，方法调用结束，栈帧就被销毁了，内存中的存储的变量数据也销毁了

class Person {
	String name;
	int age;
}

public class App {
	public static void main(String[] args) {
		App.doWork();//调用doWork方法
		Person p = new Person();	//记住每次new 就表示在堆空间开辟一块空间
	}

	private static void doWork() {
		int a = 10;
		int b = 20;
	}
}

当doWork方法被调用时，在栈顶位置分配doWork方法的内存空间，存储局部变量数据。

当doWork方法调用结束，doWork方法的栈帧就被销毁，main方法重新回到栈顶位置。

堆中存储的都是new出来的对象（数组其实也是对象）。

9.3.类和对象的关系（了解）

面向对象思想中有两个非常重要的概念，类和对象，其中:

• 类（class），是对某一类事务的抽象描述（状态和行为），如下图的抽象女人图。
• 对象（object），表示现实生活中该类事物的个体，也称之为实例，如下图的每一个具体的女人。
• 类可以看作是对象的数据类型，就好比无论你是谁，只要是女人，那么类型就是女人。
• 抽象的类型 描述具体的 对象

类名 变量名 = 对象;

int i = 10;

int[] arr = {};

Person p = Person对象;

String s = “”;

上图，从左往右看是抽象的过程，从右往左看是实例化的过程，所谓实例化就表示根据类这个模板制造出每一个对象。

任何事物存在就有一定的功能，在面向对象中，任何事物都可以看成对象，也就是万物皆对象的概念。

注意，在开发中，必须先有类，再使用new关键字根据类来创建出对象。

9.4. 类的定义（重点掌握）

类是拥有相同特性（状态）和行为（功能）的多个对象的抽象。而一般的，描述类或者说定义类，就从状态和行为上分析，那么怎么来表示状态和行为呢？

• 使用成员变量来表示状态
• 使用成员方法来表示行为

定义语法格式: 合理

public class 类名{
	//可编写0到N个成员变量
	[修饰符] 数据类型	变量名1;
	[修饰符] 数据类型	变量名2;

	//可编写0到N个成员方法
	[修饰符] 返回值类型  方法名称(参数){
		//方法体
	}
}

注意：

• 成员变量和方法都 不 能使用static修饰，修饰符是可选用的，都先不使用任何修饰符
• 在面向对象设计中，描述对象的类和测试类分开来编写
• 在描述对象的类中，不需要定义main方法，专门在测试类中提供main方法。

需求：描述一个猫类Cat，猫有名字和年龄两个状态，有自我介绍的行为。

public class Cat {
	String name;
	int age;
	void say() {
		System.out.println("我是" + name + ",今年" + age + "岁");
	}
}

注意：此时的Cat类前面的public单词是一个修饰符，表示公共访问权限，先用着，后面细讲。

9.5. 对象操作（重点掌握）

9.5.1. 对象基本操作（重点掌握）

• 创建对象

  类名 对象变量名 = new  类名();
  

  1. 直接打印对象的时候，打印的是类似于数组一样的hashCode值（先不管，后面讲）

  System.out.println(对象变量名);//格式如：类名@3294e4f4
  

  2. 匿名对象：创建对象之后没有赋给某一个变量，只能使用一次（先知道）

  new  类名();
  

• 操作对象的字段（成员变量）

  1. 给字段设置数据

  对象变量名.字段名 = 值;
  

  2. 获取字段数据

  数据类型 变量 = 对象变量名.字段名;
  

• 调用对象的方法

  对象变量名.方法(参数);
  
  

测试代码如下：

public class CatDemo {
	public static void main(String[] args) {
		// 1：创建Cat对象,对象的变量名为c
		Cat c = new Cat();
		// 2:获取字段的值,先看看字段的初始值
		String n = c.name;
		int a = c.age;
		System.out.println("名字=" + n);
		System.out.println("年龄=" + a);
		// 3：给字段设置值
		c.name = "汤姆";
		c.age = 5;
		// 4:设置字段值后，再获取字段的值
		n = c.name;
		a = c.age;
		System.out.println("名字=" + n);
		System.out.println("年龄=" + a);
		// 5:调用对象的方法
		c.say();// 猫说话的功能
	}

9.5.2. 对象实例化过程-内存分析（掌握）

分析内存的目的，是为了更清楚数据在内存中的存储和变化，方便我们理解和分析。

• 创建对象Cat c = new Cat();

此时通过c对象查看name和age，初始值分别是null和0。

• 通过对象给字段设置数据 c.name = “汤姆”; c.age = 5;

此时通过c对象查看name和age的值，分别是汤姆 和5。

• 通过对象调用方法 c.say();

• say方法调用结束，也就是c.say();代码执行完成。say方法栈帧从栈内存销毁（出栈）后如图二。

9.6.构造器（重点掌握）

创建猫对象的时候，代码如下:

Cat c1  = new Cat();

其实这段代码，是在通过调用Cat类的构造器，来创建对象。

构造器，也称之为构造方法（Constructor），作用是用来创建对象和给对象做初始化操作。

构造器的语法和特点：

[public] 类名(参数){
   //方法体
}

Cat类的构造器：

public class Cat {
	public Cat() {
	}
    //省略其他代码
}

• 构造器名称和类名相同
• 不能定义返回类型
• 构造器中不能使用return语句

9.6.1.默认的构造器（掌握）

​ 但是我们发现在Cat类中，却找不到该构造器，而在创建对象时却没有报错，这是为什么？如果源文件中没有定义构造器，编译器在编译源文件的时候，会创建一个缺省的构造器。

public class Cat {
	String name;
	int age;

	public Cat() {
	}
	
	void say() {
		System.out.println("我是" + name + ",今年" + age + "岁");
	}
}

默认构造器的特点：无参数、无方法体。

类是否使用public修饰（下面结论知道就行）：

• 使用，则编译器创建的构造器也使用public修饰
• 没有，则编译器创建的构造器也不使用public修饰

9.6.2.通过构造器设置初始值（掌握）

之前，我们是先通过一个默认参数构造器，先创建出一个对象再初始化（给字段设置值）

Cat c1  = new Cat();
c.name = "汤姆";
c.age = 5;

有了构造器之后，可以直接通过构造器同时完成对象创建和初始化操作。

public class Cat {
	String name;
	int age;

	public Cat(String n, int a) {
		name = n;
		age = a;
	}

	void say() {
		System.out.println("我是" + name + ",今年" + age + "岁");
	}
}

注意：当显示定义出构造器之后，编译器不再创建默认的构造了。

Cat c2 = new Cat("加菲", 6);
c2.say();

因为不再有无参数构造器，之前的创建对象的代码报错。

Cat c = new Cat();	//	此行报错

此时，我们可以在Cat类中同时存在带参数和不带参数的构造器，他们之间的关系就是重载关系。

public class Cat {
	String name;
	int age;
    //无参数构造器
	public Cat() {
	}
    //带参数构造器
	public Cat(String n, int a) {
		name = n;
		age = a;
	}
    //其他代码
}

小结：构造器就先了解到这即可，后面再讲，现在需要掌握的是：

记住构造器的定义语法和功能，手动写出构造器代码，认识同一个类中的多个构造器之间是重载关系。

10.封装思想

封装是面向对象三大特征之一，其含义有两个（掌握思想）：

• 把对象的字段和方法存放在一个独立的模块中（类）
• 信息隐藏，尽可能隐藏对象的数据和功能的实现细节

封装的好处:

• 保证数据的安全性，防止调用者随意修改数据
• 提高组件的重用性，把公用功能放到一个类中，谁需要该功能，直接调用即可

没有封装带来的困惑：

学生类：

public class Student{
	String name;
	int age;

	void say() {
		System.out.println("我是" + name + ",今年" + age + "岁");
	}
}

测试类：

public class StudentDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.name = "小明";
		s.age = -12;
		s.say();//我是小明,今年-12岁
	}
}

​ 此时从代码语法上来看，是没有任何问题的，但是从逻辑上来分析人的年龄怎么能是负数呢？造成该问题的根本原因就是：可以随意访问对象中的字段。

​ 那么问题来了，怎么才能限制不能随意访问字段数据呢？

​ 此时，就该访问修饰符登场了！

10.1.访问修饰符（必须记住）

​ 车库有一个车位，旁边写着”公共车位”，那么该车位就是公共的，谁都可以访问它。如果我在车位旁边写上“私家车位”，那么该车位就只能是我自己来访问。外界（除我之外）都访问不了，像“公共”、“私有”这种限制外界访问的标记符号，就称之为访问修饰符。

​ 访问修饰符，决定了有没有权限访问某个资源。

​ 封装其实就是要让有些类看不到另外一些类中定义的字段和方法。Java提供了不同的访问权限修饰符来限定类中的成员让谁可以访问到。

• private：表示当前类私有的，类访问权限，只能在本类中操作，离开本类之后就不能直接访问
• 不写（缺省）：表示当前包私有，包访问权限，定义和调用只能在同一个包中，才能访问
• protected：表示子类访问权限，同包中的可以访问，即使不同包但是有继承关系也可以访问
• public：表示公共的，可以在当前项目中任何地方访问

private修饰符演示：

缺省和public修饰符演示：

暂时记住：把所有的字段使用private修饰，所有方法使用public修饰。

10.2. 封装使用（了解）

使用private修饰了Student类中的字段，此时在测试类中访问报错。

public class Student {
	private String name;
	private int age;
}

测试类：

public class StudentDemo {
	public static void main(String[] args) {
		Student s = new Student();
		s.name = "小明";	//	此行报错，访问权限不足
		s.age = -12;	//	此行报错，访问权限不足
	}
}

此时使用private修饰字段后，在测试类中不能再操作这些字段了，怎么办？我们可以使用JavaBean的规范来解决。

10.2.1. JavaBean规范（重点掌握）

JavaBean是一种某些符合条件的特殊类，但是必须遵循一定的规范：

• 类必须使用public修饰
• 必须保证有公共无参数构造器，即使手动提供了带参数的构造器，也得手动提供无参数构造器
• 字段使用private修饰，每个字段提供一对getter和setter方法

需求：针对名为name的字段名来举例

getter方法：仅仅用于返回某一个字段的值

public String getName(){
    return   name;	//返回name字段存储的值
}

如果操作的字段是boolean类型的，此时是is方法，把 getName 变成 isName。

setter方法：仅仅用来给某一个字段设置值

public void setName(String  n){
    name = n;	//把传过来的参数n的值,存储到name字段中
}

注意：每一个字段都得使用private修饰，并提供一对getter/setter方法。

IDEA工具可以自动生成标准的getter/setter，前期必须手写。

代码如下：

public class Student {
    //通常,成员变量都需要使用private来修饰
    //访问外界随便的对变量进行访问(获取/设值)
	private String name;
	private int age;
	
	public String getName() {
		return name;
	}
	public void setName(String n) {
		name = n;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int a) {
		if(a < 0) {
			System.out.println("非法的年龄");
			return;
		}
		age = a;
	}
}

测试类：

public class StudentDemo {
	public static void main(String[] args) {
		Student s = new Student();
		// 调用setter方法设置字段数据
		s.setName("小明");
		s.setAge(12);
		// 调用getter方法获取字段数据
		String n = s.getName();
		int a = s.getAge();
		System.out.println(n + "," + a);
	}
}

学习优势：

1.包含java前后端从 0 ->1 全过程教学, 内容全面, 知识点不遗漏, 学完即可参加实际工作.
2.课程为目前项目开发常用的技术知识，向用人单位对标，学以致用。那些脱离实际，废弃不用的，太前沿的框架技术前期不建议学。
3.一起学习,打卡,一起交流,希望能营造一个和线下一样的学习环境。

需要进微信学习交流群, 或者想领取代码,文档,全套视频的同学请+v：lmm99964