A009_类_对象_构造方法

内容介绍

1. 初识面向对象（了解）
2. 什么是类与对象（了解）
3. 类的设计（掌握）
4 对象的创建与赋值取值（掌握）
5. 构造方法（掌握）
最近几天重点： （掌握）面向对象中的基本语法

1 初识面向对象

1.1 面向过程 ：

是一种编程思想，就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

我要造辆车：
Step1. 设计画图
Step2. 找矿=>挖矿=>炼铁=>打铁=>制作车体
Step3. 生产发动机、变速箱等
Step4. 养牛=>庖丁解牛=>（如果没解好，牛皮破了—>重养）牛皮=>座椅
Step5. 种树=>炼橡胶=>轮胎
Step6. 组装
Step7. 测试

1.2 面向对象 ：

就是一种编程思想，是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
如我要造辆车：
Step1. 设计画图=>保时捷设计所
Step2. 原材料：发动机=>秋名山神车五菱发动机；变速箱=>巨力三轮车24速手动变速箱；轮胎=>青岛双星牌；底盘=>兰博基尼大牛；座椅=>香奈儿
Step3. 组装=>东莞代工厂
Step4. 贴牌=>
Step5. 测试=>C-NCAP=>10星安全法兰保牌
例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用分别的函数来实现，问题就解决了。

而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为 1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的i变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

可以明显地看出，面向对象是以功能来划分问题，而不是步骤。同样是绘制棋局，这样的行为在面向过程的设计中分散在了总多步骤中，很可能出现不同的绘制版本，因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中，绘图只可能在棋盘对象中出现，从而保证了绘图的统一。

功能上的统一保证了面向对象设计的可扩展性。比如我要加入悔棋的功能，如果要改动面向过程的设计，那么从输入到判断到显示这一连串的步骤都要改动，甚至步骤之间的循序都要进行大规模调整。如果是面向对象的话，只用改动棋盘对象就行了，棋盘系统保存了黑白双方的棋谱，简单回溯就可以了，而显示和规则判断则不用顾及，同时整个对对象功能的调用顺序都没有变化，改动只是局部的。
(a+b) * c - e/f + d%j
那么，面向对象和面向过程哪种好呢？各有各个好

面向对象和面向过程都是软件开发的一种编程思想，要真正的理解一种编程思想，或者说应用在实际的开发设计中，并不是看几本书，听我说几句就能搞定的事情，需要先了解，在实际开发中应用，这样不断的思考分析、积累，从而达到理解。
举个事例，现在我手上接了一个500W的项目，接下来我需要完成这个项目，现在我有两个选择：第一是自己一人开发；第二是组建团队或者说外包。
第一，自己一个人独立开发。那么我需要做的事情可能就包括了：需求搜集、分析，原型设计，项目架构设计，编码实现，项目测试，项目实施等等。其中每一件事情都必须亲力亲为，感觉心里倒也踏实，不过这个过程可能是这样：

哈哈，接了个单高高兴兴敲代码！！

丫，咋还出bug了呢，纳尼。。。

不会吧，我都调试3个通宵了。。。

糟糕，我要崩溃了，。。。

算了，我想睡一会儿（安息吧！）

第二，组建团队开发

有了自己的团队之后，就可以不用再陪客户喝茶、吃饭、聊天、（售前售后）；不用再排异常、找bug、调网络（攻城狮）;不用再反复修改设计方案版本（射鸡湿）。那么我现在做什么呢？当然是数钱啦（嘿嘿…纯洁的笑容）。

其实我现在做的就是管理好我的团队，分配好任务，控制项目进度等，在整个过程中充当指挥者的角色。
上面的两个事例第一种是面向过程的做事方式，第二种是面向对象的做事方式。通过这样的事例从面向对象某一些方面的特征来简单的让大家有一个认识而已，更多的内容需要通过后面章节来逐步了解、加深。

2 类与对象

2.1 类和对象(引入)

比如做一个学生管理系统的项目 ：

现在模拟一种场景：现实的世界和虚拟的世界

现实生活中，学生过来学习要填写一个学员信息表。纸质文档不利于后期查询和维护，并且处理数据的效率极其底下。
所以需要做一个系统，我们需要做什么事情：
①需要设计一个模板 => 设计一个类
②复制该模板 => 创建对象
③填写具体的信息 => 对象赋值
④查询信息 => 对象取值
做这件事（设计模板和录入信息）之前先了解两个概念：类和对象。
.

3.2 类和对象(理解)

什么是类？
类是具备某些共同特征的实体的集合，是对所具有相同特征实体的抽象， 例如人类、车类、星球类,动物类, 猪类等
什么是对象？
对象是类的实例，简单的认为对象就是类中具体的个体
用一个例子给你说明一下他们的关系：
比如“人类”就是一个类，那么具体的某个人“张三”就是“人类”这个类的对象，而“名字、年龄”等信息就是对象的属性，人的动作比如“吃饭、穿衣”等就是对象的方法

类和对象的关系请看下面的图例：

类 =>【模板】
创建对象 =>【复制模板】
java语言世界：万事万物皆对象
通常都会将对象划分为两个部分，即动态部分（方法）与静态部分（成员变量）。
①静态部分：顾名思义就是不能动的部分，这个部分被称为“属性”，如一个人，它包括高矮、胖瘦、性别、年龄等属性——成员变量。
②动态部分：人可以哭泣、微笑、说话、行走，这些是这个人具备的行为（动态部分）——方法。

3 设计类（重点）

3.1 定义类

设计类语法：
public class 类名{ 
//可编写 0 到 N 个成员变量 
[修饰符] 数据类型 变量名 1; 
[修饰符] 数据类型 变量名 2; 
//可编写 0 到 N 个成员方法 
[修饰符] 返回值类型 方法名称(参数){ 
//方法体 
} 
}

示例 ： 设计一个学生类（模板）) 
/**
 *	学生类
 */
public class Student {
	/**姓名	成员变量 是类的属性，静止的部分*/
	String name;
   
	/**年龄	成员变量 是类的属性，静止的部分*/
	int age;
	
	/** 
	 * 学习方法
	 * 是类的行为，是动态的部分
	 */
	public void study() {
		System.out.println("good good study ，day day up !");
	}
}

类规范书写：
①类名大驼峰，见名知意
②成员变量名小驼峰，见名知意
③类和成员变量上方必须写文档注释；

3.2 修饰符

3.2 .1修饰符概念

对Java当中的，类，变量，方法，构造方法等等…进行修饰，赋予被修饰内容特殊意义。

3.2 .2 修饰符分类

3.2.2.1 类修饰符

• public（访问控制符）: 将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。
• abstract:将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。
• final:将一个类申明为最终（即非继承类），表示他不能被其他类继承。
• 默认不写:默认的修饰符，只有在相同包中的对象才能使用这样的类。

3.2.2.2 成员变量修饰符

• public（公共访问控制符）:指定该变量为公共的，他可以被任何对象的方法访问。
• private（私有访问控制符）:指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
• protected（保护访问控制符）:指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
• 默认不写 :在同一个包中的类可以访问，其他包中的类不能访问。
• final:最终修饰符，指定此变量的值不能变。
• static（静态修饰符）:指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
• transient（过度修饰符）:指定该变量是系统保留，暂无特别作用的临时性变量。
• volatile:指定该变量可以同时被几个线程控制和修改。

3.2.2.3 方法修饰符

• public（公共控制符: 指定此方法可以被自己和其他的类访问
• private（私有控制符）:指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
• protected（保护访问控制符）:指定该方法可以被它的类和子类进行访问。
• final:指定该方法不能被重载。
• static:指定不需要实例化就可以激活的一个方法。
• synchronize:同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
• native:本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的

4 创建对象和成员变量赋值取值（重点）

4.1 创建对象

创建对象语法：
类名 对象名 = new 类名();

例如：

public class StudentTest {

	public static void main(String[] args) {
		//3.1. 创建对象（相当于复制模板）: 语法： 类名 对象名 = new 类名();
		Student student = new Student();//必须声明一个Student类型的变量接收当前对象地址
	}
}

4.2 给对象成员变量赋值

给成员变量赋值语法：
对象名.成员变量 = 值; //注意：必须值和成员变量数据类型一致
例如：
public class StudentTest {

	public static void main(String[] args) {
		//3.1. 创建对象（相当于复制模板）: 语法：类名 对象名 = new 类名();
		Student student = new Student();//必须声明一个Student类型的变量接收当前对象地址
		
		//3.2. 对象赋值（填写信息）	语法：	对象名.成员变量 = 值;
		student.name = "苍老师";
		student.age = 37;
	}
}

4.3 对象取值和对象调用实例方法

对象取值语法：
对象名.成员变量 ; 
对象调用实例方法：
    对象名.方法名(…);
例如：
public class StudentTest {

	public static void main(String[] args) {
		//3.1. 创建对象（相当于复制模板）: 语法：类名 对象名 = new 类名();
		Student student = new Student();//必须声明一个Student类型的变量接收当前对象地址
		
		//3.2. 对象赋值（填写信息）	语法：	对象名.成员变量 = 值;
		student.name = "苍老师";
		student.age = 37;
		
		//3.3. 对象取值（相当于查询信息）	语法：	对象名.成员变量;
		System.out.println(student.name);//"苍老师"	
		System.out.println(student.age);//37		
		
		//3.4. 对象调用非static(实例)方法	语法：	对象名.方法名(...);
		student.study();
	}
}

4.4 堆栈内存图分析代码（了解）:

下面使用堆栈内存图来解释一下上面代码的流程和存储。从下图中可以看到：
① 每创建一个对象都会在堆内存中开辟一块空间，并且这块空间中具有和类（模板）中一样的成员。
② 每一个对象都被栈中的一个变量所指向，所以操作栈中的变量（student）就如同操作堆中的对象。
③ student.name = “苍老师”;其实是把字符串值赋值给student变量指向的堆中的name字段上的，而不是设置给类的，所以我们在分析代码的时候，看到new Student（）对象应该立马想到在堆中有一个对象。

5 构造方法（Constructor）(重点)

5.1 构造方法引入

new Student(); 创建一个学生类的对象
上面代码本质是调用Student中的无参数的构造方法！

5.2 什么是构造方法

1. 构造方法的结构和普通方法类似，但是和普通方法完全不同两个代码块；
2. 构造方法也是方法，意味着使用了构造方法，方法会执行，也能完成功能
3. 构造方法就是一个代码块【就是一个结构 ，构造方法和 字段 方法一样都是一个类中的成员之一】
4. 构造方法也该存在于类的结构体中

构造方法语法：

1. 构造方法的名字和类名完全一致（包括大小写完全一致）
2. 没有返回值类型（去掉不写 写void也不行 void是无返回值）
3. 构造方法方法体不能返回任何的值（即不能在方法体中return 值）
4. 其他的和普通方法类似 ，可以有修饰符（public、protected、private、默认）,可以有形参列表
5. 构造方法必须有方法体
6. 构造方法不能有任何非访问性质的修饰符修饰，例如 static、final、synchronized、abstract等都不能修饰构造方法。
   注意：new Student() 这个整体既是一个Student对象，又是调用的Student的无参数构造方法

5.3 构造方法特点

1. 类中构造方法特点：
   ① 每一个类中都至少有一个构造方法;
   ② 如果没有看到（显示的），那么存在一个隐式的无参数的构造方法;
   ③ 如果一个类中有显示的构造方法，那么隐式的无参的构造方法就不存在了;

5.4 构造方法的作用

在创建对象的同时给对象的成员变量赋值（初始化工作）

设计类语法：
public class 类名{
成员变量  (字段); 
构造方法（有参、无参）;
方法 (具体的一个功能行为); 
}
例如：
public class User {
	/**姓名*/
	String name;
	/**年龄*/
	int age;	
	/**
	 * 无参构造
	 */
	public User() {
		System.out.println("User无参构造...");
	}
	/**
	 * 有参构造
	 * 形参个数由需求决定
	 */
	public User(String n,int a) {
		name = n;//将传入的n的值赋值给成员变量name
		age = a;//将传入的a的值赋值给成员变量age
		System.out.println("User有参构造...");
	}
    public void playGame() {
		System.out.println("耍鸟...");
	}
}

5.5 构造方法注意事项和小结

1. 普通方法不要和类名一致，行业默认规则;
2. 普通方法（Method）和构造方法(Constructor)是不同的两种结构
   2.1. 普通方法的调用 ： 3种
   …2.1.1. 类名.方法名(…); -有static修饰的
   …2.1.2.对象名.方法名(…);
   …2.1.3.方法名(…); --同一个类里面 都要static 或 都没有static修饰
   2.2. 构造方法的调用 ：
   （目前为止） new 类名(…);

7 课程总结

7.1 重点

设计类、创建对象、构造方法

7.2 难点

构造方法

8.课后练习

8.1. 定义一个长方形的类（Rectangle），类中定义
两个成员变量：一个长(height)和一个宽(width)；
定义求面积的方法：public double getArea(){方法体}
并写测试类进行测试；
创建2个长方形对象，给成员变量赋值，并且调用求面积方法

8.2. 定义一个狗狗类，狗狗
有如下属性：性别，姓名
有如下方法： void eat(String food)方法
请写一个测试类测试：
创建2个狗狗对象:
一个名字 赋值为 苍苍，性别：母狗 吃：大香肠（用有参构造实现成员变量赋值），并且调用对象的吃方法
一个名字 赋值为 鹰鹰，性别：公狗 吃：大枣馒头（用对象名.成员变量的方式赋值给对应的成员变量），并且调用对象的吃方法

9.面试题

9.1.全局变量与局部变量的区别
全局变量：
局部变量：

10.扩展知识或课外阅读推荐

code-style