JavaSE 05 面向对象

第十章 面向对象

10.1 面向对象的概述

面向过程：当需要实现一个功能的时候，每一个具体步骤都要亲力亲为，详细处理每一个细节。
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。

import java.util.Arrays; //自动出现在idea中

public class Demo {

	public static void main(String[] args) {
		int[] array = { 10, 20, 30, 40 };
		
		//要求打印出格式为：[ 10, 20, 30, 40]
		//使用面向过程
		System.out.print("[");
		for (int i = 0; i < array.length; i++) {
			if (i < array.length - 2) {
				System.out.print(array[i] + ", ");
			} else {
				System.out.println(array[i] + "]");
			}
		}
		System.out.println("=====================");
		
		//使用面向对象
		//找一个JDK给我们提供好的Arrays类，其中有一个toString方法，直接就能把数组变成想要的格式的字符串
		System.out.println(Arrays.toString(array));
	}

}

• 面向对象的特点：
  面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承、多态。

10.2 类与对象

10.2.1 类

• 类是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类的事物。
  现实中，描述一类事物：
• 属性：就是该事物的状态信息
• 行为：就是该事物能够做什么

10.2.2 对象

对象是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

10.2.3 类与对象的关系

• 类是对一类事物的描述，是抽象的
• 对象是一类事物的实例，是具体的
• 类是对象的模板，对象是类的实体

10.3 类的定义

事物与类的对比

现实世界的一类事物：
属性：事物的状态信息
行为：事物能够做什么

Java中用class描述事物也是如此：
成员变量：对应事物的属性
成员方法：对应事物的行为

类的定义格式

public class ClassName { /*注意首字母大写*/
	//返回值类型 成员变量;
	int memberVariable;
	//public 返回值类型 成员方法(参数1,参数2，...) {}
	public void memberMethod() {
		
	}
}

• 定义类：就是定义类的成员，包括成员变量和成员方法。
• 成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中、方法外。
• 成员方法：和以前定义方法几乎是一样的。只不过把static去掉。

10.4 对象的定义

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。

10.4.1 创建对象

1. 导包
   也就是指出需要使用的类，在什么位置。

• 格式：

//import 包名称.类名称;
import cn.niiu.xxx.abc.ClassName;
//对于和当前类属于同一个包的情况，可以省略导包语句不写。

2. 创建

• 格式：

//类名称 对象名 = new 类名称();
ClassName name = new ClassName();

3. 使用（想用谁就用对象名点谁）

• 使用成员变量：

//对象名.成员变量名;
name.memberVariable;

• 使用成员方法：

//对象名.成员方法名(参数);
name.memberMethod();

注意：如果成员变量没有进行复制，那么将会有一个默认值，规则和数组一样。

10.4.2 使用对象类型作为方法参数

public class Demo {
	
	public static void main(String[] args) {
		ClassName name = new ClassName;
		name.memberVariable = 888;
		
		method(name);
	}
	
	public static void method(Classname param) {
		System.out.println(param.memberVariable);
	}

}

• 注意：当一个对象作为参数，传递到方法当中时，实际上传递进去的是对象的地址值。

10.4.3 使用对象类型作为方法的返回值

public class Demo {
	
	public static void main(String[] args) {
		ClassName exampleTwo = exampleOne();
		System.out.println(exampleTwo.memberVariable);
	}
	
	public static ClassName exampleOne() {
		ClassName name = new ClassName();
		name.memberVariable = 888;
		return name;
	}

}

• 注意：当一个对象作为方法的返回值时，返回值其实是对象的地址值。

10.5 局部变量和成员变量的区别

1. 定义的位置不一样
   局部变量：在方法内部
   成员变量：在方法的外部，直接卸载类当中

2. 作用范围不一样
   局部变量：只有方法当中才可以使用，出了方法就不能再用
   成员变量：整个类都可以通用

3. 默认值不一样
   局部变量：没有默认值，如果要使用必须进行赋值
   成员变量：如果没有赋值，会有默认值，规则和数组一样

4. 内存的位置不一样
   局部变量：位于栈内存
   成员变量：位于堆内存

5. 生命周期不一样
   局部变量：随着方法进栈而诞生，随着方法出栈而消失
   成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

---

10.6 面向对象三大特征之封装性

* 封装

• 封装性在Java当中的表现
  • 方法就是一种封装
  • 关键字private也是一种封装
• 封装就是将一些细节信息隐藏起来，对于外界不可见 。

* 继承

* 多态

10.7 private 关键字

定义Person的年龄时，无法阻止不合理的数值被设置进来。这时就需要用到private关键字将需要进行保护的成员变量进行修饰。

一旦使用了private进行修饰，那么本类当中仍然可以进行随意访问。但是！超出了本类范围之外就不能再直接访问了。

间接访问private成员变量，就是定义了一堆Getter、Setter方法(setXxx不能有返回值，参数类型和成员变量对应，getXxx不能有参数，返回值类型和成员变量对应)

• 格式：

//private 变量值类型 成员变量;

• 举例：

public class Demo {

	public static void main(String[] args) {
		Person person = new person();
		
		person.name = "Jack";
		//person.age = "-20"; 报错，被private保护无法直接访问。
		person.setAge(20);
		person.show();
	}
	

}

public class Person {
	
	String name;
	private int age;
	
	public void show() {
		System.out.println("我叫：" + name + ",年龄：" + age);
	}
	
	//这个成员方法，专门用于向age设置数据
	public void setAge(int mun) { //set变量名为固定写法，变量名的首字母要大写
		if (num < 100 && num > 0) {
			age = num;
		} else {
			System.out.println("数据错误");
		}
	}
	
	//这个成员方法，专门用于获取age的数据
	public int getAge() {
	 return age;
	}
}

• private关键字在boolean中的特殊情况
  Getter 方法要写成isXxx的形式

public class Student {
	
		private String name;
		private int age;
		private boolean male;
		
		public viod setName(String str){
			name = str;
		}
		
		public String getName(){
			return name;
		}
		
		public void setAge(int num) {
			age = num;
		}
		
		public int getAge(){
			return age;
		}
		
		public viod setMale(boolean b) {
			male = b;
		}
		
		//对于基本类型当中的boolean值，
		//Getter方法一定要写成isXxx的形式，而setXxx不变。
		public boolean isMale(){ 
			return male;
		}
}

public class Demo01Student {

	public static void main(String[] args) {
		Student stu = new Student();
		
		stu.setName("IU");
		stu.setAge(18);
		stu.setMale(false);
		
		System.out.println("姓名：" + stu.getName());
		System.out.println("年龄：" + stu.getAge());
		System.out.println("性别：" + stu.isMale());
	}
}

10.8 this 关键字

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，有限使用局部变量。

public class Preson {
	
	String name;
	
	public String sayHello(String name) {
		System.out.println(name + ",你好！我是" + name);
	}
	
}

如果需要访问本类中的成员变量，需要使用格式：

this.成员变量

public class Preson {
	
	String name;
	
	public viod sayHello(String name) {
		System.out.println(name + ",你好！我是" + this.name);
	}
	
}

通过谁调用的方法，谁就是this

10.9 构造方法

构造方法是一个专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式：

public 类名称(参数类型 参数名,....) { //也可以无参数
	方法体
}

注意事项：

1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2. 构造方法不要写返回值类型,连void都不要写。
3. 构造方法不能return一个具体的返回值。
4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。
6. 构造方法也是可以重载的。（方法名称相同，参数不同）

10.10 定义一个标准的类

1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一堆Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法

这样标准的类也叫做Java Bean

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

	//IDEA 可以快速生成代码 Code->Generate
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}