面向过程核心思想：自顶向下，逐步求精。
面向对象核心思想：以对象为单位，将解决客观世界问题的方式方法引入到编程领域中。
面向对象编程是面向过程的一种升级。
由于计算机不断地发展需要计算机解决人类在现实世界中的问题，所以必须在程序中模拟出客观世界存在事物，而对象就是对事物的一种统称
一句话总结：万物皆对象，一切客观存在的事物在面向对象思想中统称为对象。
1. 对象所具备的属性：对象有什么，决定了对象的特征。
2. 对象所具备的方法：对象能做什么，决定了对象的行为。
如图所示：
对象的属性，使用变量表示。
对象的方法，使用函数表示。
如图所示：
类就是对象的模板（设计图），用来描述对象具备的属性（特征），方法（行为）。
JVM类似于工厂，通过类（模板）创建对象（类的实例）。
类是从多个相同类型的对象中抽取出来的共性，只保留程序所关注的部分。
如图所示：
// 类：对象的模板（设计图），JVM需要通过类创建相同的对象
// 在类中定义对象所具备的属性（特征），方法（行为）
// Student类的模板
class Student{//学生类
//属性
String stuId;//学生的学号
String name;//学生的姓名
int age; //学生的年龄
boolean sex;//学生的性别
double score;//学生的成绩
}
访问权限修饰符 返回值类型 方法名(参数表) 抛出的异常{
}
public void test(){
}
class Student{//学生类
//属性
String stuId;//学生的学号
String name;//学生的姓名
int age; //学生的年龄
boolean sex;//学生的性别
double score;//学生的成绩
//方法
public void study(){//学习方法
System.out.println("学习使我快乐");
}
public void sayHello(){//打招呼方法
System.out.println("你好！");
}
}
语法如下：
new 类名();
演示的代码如下：
new Student();//创建一个学生对象
new Teacher();//创建老师对象
new Product();//创建商品对象
注意：创建对象时务必保证有对应的类（.class），否则编译错误。
为引用赋值
在Java中每定义一个类，JVM中就多了一种自定义的数据类型，可以将对象保存在相同类型的引用中便于后续使用。
演示的代码如下：
Student stu1;//声明学生类型的引用
stu1 = new Student();//创建学生对象
Student stu2 = new Student();//创建对象同时赋值
每个对象都代表了客观世界中的一名学生。
模板只有一个，通过模板可以创建多个对象，每个对象都有属于自己的一块内存空间。
如图所示：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fILV7hbD-1630915842701)(D:\CoreJava\day8_object_oriented\images\7面向对象_对象独立.png)]](https://img-blog.csdnimg.cn/d5f6959e88d4435c9f32fa822d927fb1.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5a2m5peg5q2i6Lev,size_20,color_FFFFFF,t_70,g_se,x_16)
// 为属性赋值
引用名.属性名 = 值;
// 获取属性值
引用名.属性名
package com.txw.test;
public class Test {
public static void main(String args[]) {
Student stu1; // 声明学生类型的引用
stu1 = new Student(); // 创建学生对象
// 为stu1的stuId属性赋值
stu1.stuId = "10000000888";
// 为stu1的name属性赋值
stu1.name = "Adair";
// 为stu1的age属性赋值
stu1.age = 72;
// 为stu1的sex属性赋值
// stu1.sex = "男"; 为属性赋值时注意类型一致
stu1.sex = false; // 男
// 为stu1的score属性赋值
stu1.score = 1.5;
// 打印stu1的stuId属性
System.out.println( stu1.stuId );
// 打印stu1的name属性
System.out.println( stu1.name );
// 打印stu1的age属性
System.out.println( stu1.age );
}
}
每个对象都有独立的内存区域。如图所示： 
class Student{ // 学生类
/ /属性
String stuId; // 学生的学号
String name ="张三"; // 学生的姓名，在类中为属性赋值（初始化属性）
int age =18; // 学生的年龄，在类中为属性赋值（初始化属性）
boolean sex; // 学生的性别
double score; / / 学生的成绩
}
引用名.方法名( 实参 );
public static void main(String[] args) {
// 创建对象
Student stu1 = new Student();
// 为属性赋值略....
// 调用stu1的study方法
stu1.study();
// 调用stu1的sayHello方法
stu1.sayHello();
}
package com.txw.test;
class Student{ // 学生类
// 属性
String stuId; // 学生的学号
String name ; // 学生的姓名
int age; // 学生的年龄
boolean sex; // 学生的性别
double score; // 学生的成绩
double pinMoney; // 学生的零用钱
// 方法
public void study(){
System.out.println("学习使我快乐");
}
public void sayHello(){
System.out.println("你好！");
}
// 购物方法
// goods：商品
// price：价格
public double shopping(String goods,double price){
System.out.println(name+" 要购买的商品是："+goods);
System.out.println("需支付: "+ price );
pinMoney -= price; // 扣除零用钱
System.out.println("零用钱剩余："+pinMoney);
return price; // 支付对应的金额
}
}
执行流程， 如图所示：
| 局部变量 | 成员变量 | |
|---|---|---|
| 定义位置 | 方法中 | 类以内，方法以外 |
| 默认值 | 必须手动赋值 | 有 |
| 作用范围 | 定义行开始，到所在代码块结束 | 至少在本类中 |
| 命名冲突 | 重合作用范围内，不允许重名 | 可与局部变量重名，局部变量优先 |
演示的代码如下：
class MyClass{
int a; // 属性（成员变量）
public void method(){
int b; // 局部变量
}
public void m1(){
// System.out.println( b ); error超出局部变量的使用范围
System.out.println( a ); // a是成员变量可以使用
}
}
作用：允许在一个类中定义多个同名的方法，屏蔽使用时的差异，使用更加方便。
演示的代码如下：
class Calculator{ // 计算器
public void sum(int a,int b){
System.out.println( a + b);
}
public void sum1(int a, double b){
System.out.println( a + b );
}
public void sum2(double a,int b){
System.out.println( a + b );
}
public void sum3(double a,double b){
System.out.println( a + b );
}
}
由于处理的数据类型不同，需要定义不同的方法，如果方法名不同，使用者就要时刻记住什么样的方法能处理什么样的数据，对使用者造成不便。
方法重载的语法要求。
方法名相同，参数表不同（个数、类型、顺序）
参数名不同不算重载。
演示的代码如下：
class MyClass{
public void m1(){
System.out.println("m1()");
}
public void m1(int n){
System.out.println("m1(int n)");
}
public void m1(int a, int b){
System.out.println("m1(int a, int b)");
}
public void m1(String str){
System.out.println("m1(String str)");
}
}
编译器根据方法名与实参找到对应的方法调用方法。
面向对象编程套路。
1. 根据需求定义类（模板、设计图）。
2. 创建对象。
3. 访问对象的属性，调用对象方法。
思考
定义一个Account类表示账户
定义属性用户名（username），密码（password），创建时间（createDate），余额（balance）
定义方法取款（withdraw），转账（transfer)
取款方法定义一个double类型的参数，表示取款金额，在方法中打印取款金额
转账方法，打印转账
定义一个测试类，创建一个Account对象，为各个属性赋值，打印各个属性的值
调用取款方法，调用转账方法
隐藏在类中的方法，每个类至少拥有一个构造方法。
可以显式的将构造方法定义到类中。
语法如下：
访问权限修饰符 类名(参数表){
}
特点：
1. 构造方法的方法名必须与类名一致。
2. 没有返回值类型。
3. 不能手动调用。
4. 创建对象时自动调用。
5. 一个类如果没有构造方法，编译器默认提供无参构造方法。
6. 如果一个类定义了构造方法，编译器不再默认提供无参。
如图所示：
构造方法支持重载，可以在一个类中定义多个方法名相同，参数表不同的构造方法。
演示的代码如下：
class MyClass{
public MyClass(){ // 无参构造方法
System.out.println("MyClass");
}
public MyClass(int a) {// 有参构造方法
System.out.println("MyClass(int)");
}
public MyClass(int a,int b) {// 有参构造方法
System.out.println("MyClass(int,int)");
}
public void m1(){ // 一般方法
System.out.println("m1 in MyClass");
}
}
// 创建对象时 new MyClass() 用来表明，创建对象时自动调用哪个构造方法
new MyClass(); // 创建对象时自动调用无参构造方法
new MyClass( 10 ); // 创建对象时自动调用有参构造方法
new MyClass(10,20); // 创建对象时自动调用有参构造方法
作用：使用构造方法为属性赋值。
步骤：
1. 为类添加有参构造方法，参数个数、类型、顺序与属性一致
2. 使用形参为属性赋值
3. 创建对象时使用有参构造方法，传入对应的实参为形参赋值
演示的代码如下：：
class Account{ // 账户类
String username; // 用户名
String password; // 密码
int age; // 年龄
double balance; // 余额
// 1. 为类添加有参构造方法，参数个数、类型、顺序与属性一致
public Account(String a,String b,int c,double d){
// 数据传递：将接收到的数据为属性赋值
// 2.使用形参为属性赋值
username = a; // yangcs
password = b; // 123456
age = c; // 18
balance = d; // 599999D;
}
}
演示的代码如下：
// 利用构造方法为属性赋值
// 3. 创建对象时使用有参构造方法，传入对应的实参为形参赋值
Account ac = new Account("yangcs","123456",18,599999D);
如图所示：
在实际开发环境中通常都会写两个构造方法，一个无参，一个有参。
演示的代码如下：
class Account{ // 账户类
String username; // 用户名
String password; // 密码
int age; // 年龄
double balance; // 余额
public Account(){} // 无参构造方法
// 1.为类添加有参构造方法，参数个数、类型、顺序与属性一致
public Account(String a,String b,int c,double d){
// 数据传递：将接收到的数据为属性赋值
// 2.使用形参为属性赋值
username = a;
password = b;
age = c;
balance = d;
}
}
MyClass mc1 = new MyClass();
System.out.println( mc1 ); // classes.MyClass@15db9742
mc1.m1();
MyClass mc2 = new MyClass();
System.out.println( mc2 ); // classes.MyClass@6d06d69c
mc2.m1();
class MyClass{
int a = 10;
// mc1.m1(); this: mc1
// mc2.m1(); this: mc2
public void m1(){
/ /this表示当前对象的引用，
// 哪个对象调用的m1 this就是那个对象
System.out.println( this );
}
}
演示的代码如下：
class MyClass{
int a = 10; // 属性
public void method(){
int a = 100; // 局部变量
System.out.println( a ); // 打印局部变量
m1(); // 调用m1方法
System.out.println( this.a ); // 打印a属性
this.m1(); // 调用m1方法
}
public void m1(){ // 方法
System.out.println( "m1 in MyClass ");
}
}
class Account{ // 账户类
String username; // 用户名
String password; // 密码
int age; // 年龄
double balance;/ / 余额
// 完整的构造方法
public Account(String username,String password,int age,double balance){
// 使用this.明确成员变量（属性）
this.username = username;
this.password = password;
this.age = age;
this.balance = balance;
}
}
// 在构造方法中的第一行。
this(); // 调用本类的无参构造方法
this(实参); // 调用本类的有参构造方法
class MyClass{
int a;
int b;
// 无参构造方法
public MyClass(){
// 3000行代码
System.out.println("MyClass()");
}
// 有参构造方法
public MyClass(int a){
this(); // 调用本类的无参构造方法
this.a = a;
System.out.println("MyClass(int n) ");
}
// 有参构造方法
public MyClass(int a, int b){
//this(); // 调用本类的无参构造方法
// this.a = a;
this( a ); // 调用本类有参构造方法
this.b = b;
System.out.println("MyClass(int a, int b)");
}
}
1. 为对象分配空间,属性被赋予默认值。
2. 初始化属性，如果属性后有 = 号赋值语句，则此时完成赋值（初始化）。
3. 调用构造方法，可以通过有参构造再次为属性赋值（常用）。
如图所示：
概念：
尽可能的隐藏对象的内部实现细节，控制用户对对象的访问程度，保障内部的数据安全。
演示的代码如下：不安全的设计。
class Account{ // 账户类
String username; // 用户名
String password; // 密码
int age; // 年龄
double balance; // 余额
}
修饰符：修饰程序中的各个组件（类、方法、属性…），被修饰的组件拥有不同的特点与权限。
private访问权限修饰符特点：
private ：私有的，可以修饰属性、方法、构造方法。
被private修饰的组件只能在本类中使用，对外不可见。
演示的代码如下：
class Account{ // 账户类
private String username; // 私有的用户名（只能在本类中使用）
private String password; // 密码
private int age; // 年龄
private double balance; // 余额
}
public class TestEncapsulation{
public static void main(String[]args){
Account ac = new Account();
// 为属性赋值
// ac.username = "yangcs"; Error
// ac.password = "123456"; Error
// ac.age = 18;
// ac.balance = 59D;
//获取属性的值
// System.out.println( ac.username );
// System.out.println( ac.password );
// System.out.println( ac.age );
// System.out.println( ac.balance );
}
}
过度安全，所有的属性都无法被外部进行访问。
public 返回值类型 get属性名(){
return 属性;
}
// 由于get方法需要将属性的值返回，需要返回值类型与属性类型一致
// get方法注意使用驼峰命名法
演示的代码如下：
class Student{
private String name;
private int age;
private double score;
// 用于获取name属性的get方法
public String getName(){
return name;
}
// 用于获取age属性的get方法
public int getAge(){
return age;
}
// 用于获取score属性的get方法
public double getScore(){
return score;
}
}
public void set属性名(与属性相同的参数){
this.属性名 = 参数名;
}
class Student{
private String name;
private int age;
private double score;
// 用于设置name属性的set方法
public void setName(String name){
this.name = name;
}
// 用于设置age属性的set方法
public void setAge(int age){
this.age = age;
}
// 用于设置score属性的set方法
public void setScore(double score){
this.score = score;
}
// 用于获取name属性的get方法
public String getName(){
return name;
}
// 用于获取age属性的get方法
public int getAge(){
return age;
}
// 用于获取score属性的get方法
public double getScore(){
return score;
}
}
设置属性。演示的代码如下：
Student stu = new Student();
stu.name = "yangcs"; // 封装前为属性赋值
stu.setName("yangcs"); // 封装后为属性赋值
stu.age = 18; // 封装前为属性赋值
stu.setAge( 18 ); // 封装后为属性赋值
获取属性。演示的代码如下：
Student stu = new Student();
stu.name; // 封装前获取属性
stu.getName(); // 封装后获取属性
stu.age // 封装前获取属性
stu.getAge(); // 封装后获取属性
1. 私有化每个属性。
2. 为每个属性提供公开的get/set方法。
封装后所有对于属性的操作都要通过get/set方法
可以在get/set方法中加入数据验证的代码确保属性的安全，例如：
// 用于获取password属性的get方法
public String getPassword(){
return "******"; // 返回password属性的值
}
// 用于设置age属性的set方法
public void setAge(int age){
if(age<1) {/ /数据验证
System.out.println("非法的年龄！");
return;
}
this.age = age;
}
1. 没有封装：超市门口无人看守，无人管理无法保证客户与商品的安全。
2. 属性私有：封住超市的所有出入口，则安全过度。
3. 提供公开的get/set：为超市设置出口（get）、设置入口（set），在出口增加安检，保障内部商品与客户的安全。
package com.txw.test;
class ClassA{
public void mehod(int value){
System.out.println(value);
}
public void mehod(){
System.out.println(value);
}
int value;
}
public class TestClassA {
public static void main(String [] args) {
ClassA classA = new ClassA();
classA.value = 10;
classA.mehod();
classA.mehod(20);
}
}
A. 编译不通过 。
B. 输出 10 10。
C. 输出 10 20。
D. 输出 0 20 。
6. 下面关于构造方法描述错误的是(BC)。
A. 构造方法的名必须和类名一致。
B. 构造方法没有返回值类型，即声明部分为 void 类型。
C. 一个类中可能不存在任何构造方法。
D. 构造方法可以为属性赋值 。
原因：B选项错误，构造方法是没有返回值类型，void是返回值类型中的一种。 C选项错误，因为类中一定会有构造方法，及时自己不定义，编译器会默认提供一个无参的。
7. 构造方法什么时候会被调用(B)。
A.类定义时。
B. 创建对象时。
C. 调用对象方法时。
D. 使用对象的变量时。
8. 对以下程序描述正确的是(CD)。
class ClassA{
public void ClassA(String str){
System.out.println(str);
}
public void mehod(){
}
}
A. 程序编译报错 。
B. ClassA 类中定义了有参数的构造方法。
C. ClassA 类中只有一个默认的无参数的构造方法。
D. method 方法需要通过对象的调用才能被执行。
原因：public void ClassA(String str){}这不是构造方法，只是一个普通方法， 构造方法没有返回值类型。
9… 仔细阅读以下程序，程序编译是否通过，如果通过写出运行结果；否则说明原因。
package com.txw.test;
class MyClass{
int value;
}
public class TestRef {
public static void main(String [] args) {
int a = 10;
int b = a;
b ++;
System.out.println(a);
MyClass mc1 = new MyClass();
mc1.value = 10;
MyClass mc2 =mc1;
mc2.value ++;
System.out.println(mc1.value);
}
}
答：输出结果10，11。
原因：第一个输出结果是10，因为a的值赋值给b，a和b的值都是10，b++变为11，打印a的值还是10 第二个结果为11，mc1的value属性赋值为10，mc1和mc2指向同一个对象，mc2.value++将对象的value属性变为 11，打印mc1的value也是11。
10. 仔细阅读以下程序，程序编译是否通过，如果通过写出运行结果；否则说明原因。
package com.txw.test;
class ClassA{
int value = 10;
}
public class TestClassA {
public static void main(String [] args) {
ClassA c1 = new ClassA();
changValue(c1);
System.out.println(c1.value);
}
public static void changValue(ClassA c ){
c = new ClassA();
c.value = 30;
}
}
答：输出结果 10 创建c1对象value属性值为10，c1作为实参传递赋值给c，两个引用此时指向同一个对象，但是c引用在方法中进行 了重新赋值，指向了新的对象空间将这个空间中value属性赋值为30，方法调用结束，c引用变为垃圾，程序回到调 用 位置，打印c1的value还是10没有改变。
11. 仔细阅读以下程序，程序编译是否通过，如果通过写出运行结果；否则说明原因。
package com.txw.test;
class ClassA{
public ClassA (){
System.out.println("ClassA()");
}
}
class ClassB{
public ClassB (){
System.out.println("ClassB()");
}
}
class ClassC{
ClassA a = new ClassA();
ClassB b;
public ClassC (){
System.out.println("ClassC()");
b = new ClassB();
}
}
public class TestClassA {
public static void main(String [] args) {
ClassC c = new ClassC();
}
}
答：输出结果：ClassA() ClassC() ClassB()。
12.关于 this 的描述正确的是(AC)。
A. this 代表当前对象。
B. this. 只能应用在构造方法中。
C. this()只能应用在构造方法中。
D. this. 只能放在方法的第一行语句。
13. 编程：定义一个 Dog 类，类中属性有名字、年龄、性别(true-公)，
要求如下：
(1) 提供一个无参数的构造方法和一个带有三个参数的构造方法 。
(2) 类中定义一个无参数的 play 方法：输出 宠物狗。
(3) 类中定义一个带有一个参数的 play 方法，参数类型为 int hours，打印输出玩的小时数。
(4) 定义一个测试类，分别用无参数的构造法和有参数的构造方法创建对象，并对属性赋值，分别 将对象的信息打印在控制台上，调用 play 方法。
演示的代码如下：
package com.txw.test;
public class Test {
public static void main(String[] args) {
Dog d = new Dog();
d.name = "土狗";
d.age = 3;
d.sex = true;
System.out.println(d.name + " " + d.age + " " + d.sex);
d.play(); d.play(10);
Dog d2 = new Dog("哈皮", 4, false);
System.out.println(d2.name + " " + d2.age + " " + d2.sex);
d2.play(); d2.play(20);
}
}
class Dog {
String name; // 姓名
int age; // 年龄
boolean sex; // 性格
public Dog() {
}
public Dog(String name, int age, boolean sex) {
this.name = name; this.age = age; this.sex = sex;
}
public void play() {
System.out.println("宠物狗");
}
public void play(int hours) {
System.out.println("玩" + hours + "个小时");
}
}
package com.txw.test;
public class Test {
public static void main(String[] args) {
Vehicle v = new Vehicle("劳斯莱斯", "金色");
v.move();
v.showInfo();
}
}
class Vehicle {
String brand; // 商标
String color; // 颜色
public Vehicle(String brand, String color) {
this.brand = brand;
this.color = color;
}
public Vehicle() {
}
// 移动
public void move() {
System.out.println("我已经被启动");
}
// 展示详情
public void showInfo() {
System.out.println(brand + " " + color);
}
}
package com.txw.test;
public class Test{
public static void main(String[] args) {
Number n = new Number(20, 10);
n.add();
n.subtration();
n.multip();
n.divsion();
}
}
// 计算器
class Number {
int v1;
int v2;
public Number() {
super();
// TODO Auto-generated constructor stub
}
public Number(int v1, int v2) {
super();
this.v1 = v1;
this.v2 = v2;
}
// 加法
public void add() {
System.out.println(v1 + v2);
}
// 减法
public void subtration() {
System.out.println(v1 - v2);
}
// 乘法
public void multip() {
System.out.println(v1 * v2);
}
// 除法
public void divsion() {
System.out.println(v1 / v2);
}
}
package com.txw.test;
public class Test {
public static void main(String[] args) {
User u1 = new User("小明", "woaijava");
User u2 = new User("小红", "wofeichangaijava");
u1.show();
u2.show();
}
}
// 用户类
class User {
String ID;
String passworld; // 密码
String email; // 邮箱
// 两参构造，email默认赋值:用户名+@qq.com.cn
public User(String iD, String passworld) {
super(); ID = iD;
this.passworld = passworld;
email = ID + "@qq.com.cn";
}
public User(String iD, String passworld, String email) {
super();
ID = iD;
this.passworld = passworld;
this.email = email;
}
// 展示用户信息，密码xxx展示
public void show() {
System.out.println("账号: " + ID + ",密码:xxx" + ",邮箱：" + email);
}
}
package com.txw.test;
public class Test {
public static void main(String args[]) {
Worker w = new Worker("zhangsan", 26, 10000.0);
Address addres = new Address("北京市海淀区清华园1号院", "100010");
w.address = addres;
}
}
// 工人类
class Worker {
String name; // 姓名
int age; // 年龄
double salary; // 工资
Address address; // 地址（属性的类型是Address类型）
public Worker() {
}
public Worker(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public void work() {
System.out.println("work");
}
public void work(int hours) {
System.out.println("worker works for " + hours + " hours");
}
}
// 地址类
class Address {
String address;
String zipCode;
public Address() {
}
public Address(String address, String zipCode) {
this.address = address;
this.zipCode = zipCode;
}
}
总结如图所示：
