第6章 面向对象

面向对象

Java是一个面向对象的程序设计语言。基本思想是把问题看成若干个对象，对象之间彼此独立，但它们可以相互配合、协调、组合。共同完成整个程序要实现的目标与功能。

1、基本概念

1.1 对象

对象是客观事物的一个实体，面向对象就是，对对象进行分析与归纳，找到解决的问题与办法。

1.2 属性与方法

对象都具有属性和方法。
属性是对象的一些特征描述，对于人这个对象，具有身高、年龄、体重、姓名等特征，这些特征就是对象的属性。
方法是对象的作用与行为，人这个对象的方法有跑、吃、跳等行为，这就是方法。

1.3 类

类就是具有相同属性和方法的一组对象的集合，是关于对象的集合。类可以定义对象所拥有的属性和方法。
类与对象的关系，就像模型与模具的关系，类是模具，对象是类创造的模型。类是抽象的概念，对象是实体化的类。

2、定义

2.1 定义类

定义类的语法格式是：

[访问修饰符] class 类名｛
// 省略
｝

注释：访问修饰符 public、private是可选的。
class是声明类的关键字。
按照命名规范，类名首字母应该大写。

2.2 定义属性

定义类的语法格式是：

[访问修饰符] 数据类型 属性名；

注释：访问修饰符 public、private是可选的。
与声明变量类似。

2.3 定义方法

定义类的语法格式是：

[访问修饰符] 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2，…)｛
//省略方法体
｝

注释：访问修饰符 public、private是可选的。
	返回值类型是void，则不必再方法体中添加关键字 return，但可以使用 return 关键字
退出方法体。
	返回值类型不是 void ，则必须在方法体中使用 return 关键字。
	“参数1，参数2”为参数列表，参数列表的参数可单选、可多选，也可以不设置参数，
但小括号不能省略。

public class Person{//定义类
	
	public String name;//定义属性
	String gender;
	int age;
	
	public void run(int number){//定义方法
		System.out.println("我可以跑"+number+"米");
	}
	
}

3、对象

对象是类的一个实例。对象可以调用类的属性和方法。

3.1 创建对象

创建对象的语法：

类名 对象名 = new 类名()；

注释：new是关键字。
	 左边的类名是对象的数据类型，即对象所属的类的名称。
	右边的 类名() 是类的构造方法，构造方法有含不含参数之分，请注意正确的创建。

3.2 使用对象

在Java中，要使用类的属性和方法，需要使用 “.” 。

语法格式：

对象名.属性
对象名.方法()

Person xiaoming=new Person();//对象的实例化

		xiaoming.gender="男";//给给对象的属性赋值
		xiaoming.age=18;
		xiaoming.name="小明";
		
		xiaoming.run(1000);//调用对象的方法

注释：对象的实例化一般在“main”方法中进行实例化。

3.3 对象与数组

可以把对象作为数组的元素，组成对象数组。

public class Person {
		public int age;//年龄
		public String name;//姓名
		public Person(int age,String name){//有参构造方法
			this.age=age;
			this.name=name;
			}
	public static void main(String[] args) {
		//对Person类进行实例化，每个实例可以作为数组的元素

		//通过遍历来访问数组内部的对象元素，进一步访问对象的属性
		
		Person[] person={new Person(24,"李明"),new Person(25,"李晓"),
		new Person(26,"王倩")};
		
		//记住与普通数组读取的区别
		for(int i=0;i<person.length;i++){
			System.out.println("age属性是:"+person[i].age+",name属性是:"+person[i].name);
		}
	}

4、方法

类的方法包括成员变量和成员方法。其中，方法包含有参和无参两种。

4.1 无参数与有参数的方法

//无参数的方法
public void work(){
		System.out.println(this.name+"的工作理念:干活挣钱有饭吃");
	}
	
//有参数的方法
public void work(String content){
	System.out.println(this.name+"的工作理念:"+content);
}

两种方法的调用：

//无参数方法调用
对象名.work();
//有参方法的调用
对象名.work(参数)；

注释：有参方法的调用需要在方法的括号内填写上参数。
创建work()方法时，括号内的参数是形式参数，而调用方法是时，传入的参数叫做实际参数。

4.1.1 基本数据类型和引用类型作为参数传递时的不同

基本数据类型在传递参数时，传递的是变量的值，一个变量值的改变不影响另有一个变量的值。

//基本数据类型
int num1=32;
int num2=num1;//num1赋值给num2，此时num2=32
num2=51;//给num2赋值
System.out.println(num1);//num1仍然是32，
System.out.println(num2);//num2变成了51

而引用数据类型（数组、接口、对象、字符串）在传递参数的时候，传递的是引用的地址而不是值。所以，两个引用类型指向的是一个地址。一个引用值的改变
会导致另一个引用值的改变。

	String name;
	int age;

	public static void main(String[] args){
	Person p1=new Person();//实例化对象
	p1.age=25;
	Person p2=p1;//创建一个p2对象与p1对象指向同一个地址。
	p2.age=p1.age;//p1赋值给p2，
	p2.age=35;//p2的改变，p1也会改变
	System.out.println(p1.age);//35
	System.out.println(p2.age);//35

public class Student {
	int age;
	public Student() {
		
	}
	
	public void calculate(int num){
		num++;
		System.out.println(num);
	}
	
	public void multiply(Student stu){
		stu.age+=1;
		System.out.println(stu.age);
	}
}
----------------------------------------------------------
public class Test {

	public static void main(String[] args) {
		Student stu=new Student();
		stu.age=18;
		stu.multiply(stu);//方法内部的age=19;
		System.out.println(stu.age);//age=19;
		
		int num=1;
		stu.calculate(num);//方法内部的num=2
		System.out.println(num);//num=1

	}

}

4.2 方法的重载

方法重载就是指在一个类中，定义的多个同名的方法，但是方法的参数个数不同，参数类型不同。上述4.1的work()方法，一个无参，一个有参。方法名相同，这就是方法的重载

//方法的重载：方法名相同，参数的类型和个数不同
public void work(){
		System.out.println(this.name+"的工作理念:干活挣钱有饭吃");
	}
	
public void work(String content){
	System.out.println(this.name+"的工作理念:"+content);
}

4.3 构造方法

类名 对象名 = new 类名()；
在创建对象时讲的过，new关键字后面的 类名() 就是构造方法。
就是类构造对象时调用的方法，主要用来实例化对象。
构造方法是在对象初始化的时候就存在的。所以构造方法是为了给创建对象时，在类中添加一些初始化的数据。

构造方法的格式：
[访问修饰符] 方法名 ([参数列表]){
//省略方法体
}

注释：构造方法没有返回值。
	默认的构造方法没有参数，所以参数列表可选。
   构造方法名必须和类名一致。
   当开发人员没有定义构造方法的时候，系统会默认一个构造方法。
   如果已经定义了一个构造方法，java不在添加默认的构造方法。

public class Person {
	
	String name;
	String gender;
	
	public Person(){//无参构造方法
		name="张三";
		gender="男";
	}
	
	public Person(String name,String gender){//有参构造方法
		this.name=name;
		this.gender=gender;
	}
	
	public static void main(String[] args){
	
		Person p1=new Person();//无参数构造实例化
		Person p2=new Person("李四","男");//有参数构造实例化
		
		System.out.println(p1.name);
		System.out.println(p2.name);
	}

}

4.4 this关键字

在成员变量中多次使用this关键字。
this关键字是对一个对象的默认引用。每个实例的方法内部独有一个this的引用变量，指向调用这个方法的对象。

this关键字的使用举例：

4.4.1 使用this调用成员变量，解决成员变量与局部变量的同名冲突

public void setName(String name){
		this.name=name;//局部变量与成员变量同名，使用this调用成员变量。
	}
	
public void setxingMing(String xm){
		name=xm;//局部变量与成员变量不同名，使用this调用成员变量时，this可以省略。
}

4.4.2 使用this调用成员方法

public void play(){
	this.print();//print()为成员方法
	}

4.4.3 使用this调用重载的构造方法，只能在构造方法中使用，且必须是构造方法的第一条语句

public class Person {
	
	String name;
	String gender;
	int age;
	
	public Person(String name){
		this.name=name;
	}
	
	public Person(String name,String gender){
		this(name);//调用重载的构造方法
		this.gender=gender;
	}
	
	public Person(String name,String gender,int age){
		this(name,gender);//调用重载的构造方法，必须是第一条
		this.age=age;
	}
	
}

5、变量

在类中，直接定义在类中的变量，成为成员变量。它定义在方法的外部。
而，局部变量是定义在方法内部的变量。

public class Person{

	//name、gender、age就是成员变量
	String name;
	String gender;
	int age;
	
	public String work(){
		int age=18;//age定义在方法体内，就是局部变量
		System.out.println("在"+age+"的目标是实现自身价值和理想");
	}
｝

5.1 变量成员与局部变量的区别

1、作用域不同，成员变量是类的成员，在整个类中都可以被使用。而局部变量只能作用在它的方法体中，外部无法访问到。
2、初始值不同，成员变量如果没有定义它的值，类会默认它的值为零，引用类型的值为null。而局部变量必须定义它的初始值。java不会给局部变量赋值。
3、同一个方法中，不能有同名的局部变量，不同的方法可以有相同的局部变量。
4、局部变量可以和成员变量同名，使用时，局部变量优先级更高。

6、封装

封装就是将类的属性信息隐藏在类的内部，不循序允许外部直接访问。
但可以通过类提供的方法去访问隐藏信息（这个方法就是setter和getter方法）。
封装可以隐藏类的细节，让程序员只能通过方法来访问，来限制不合理的操作。有效避免了外部错误对这个对象的影响、减少耦合性。降低关联性。

6.1 封装，首先要修改属性的可见性

需要将类中属性的public修改为private。

public class Person {
	private String name;
	private String gender;
	private int age;
｝

6.2 为私有属性设置setter和getter方法

可以手动设置，也可以由系统添加。

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;
}

6.3 为setter方法设置属性的限制

public void setGender(String gender) {
	if(gender.equals("男") || gender.equals("女")){
		this.gender = gender;
	}else{
		System.out.println("性别不合法");
	}
	
}

public int getAge() {
		return age;
	}

public void setAge(int age) {
	if(age<0 || age>150){
		System.out.println("输入的年龄不合法");
		
	}else{
		this.age = age;
	}

6.4 通过setter和getter访问类的属性

public class Test {

	public static void main(String[] args){
		Person person=new Person();
		person.setAge(35);//setter方法设置年龄
		System.out.println(person.getAge());//getter获取年龄的值
		
	}
}

7 访问修饰符

7.1 类的访问修饰符

7.2 静态关键词：static

1、类的所有实例可以共享静态变量
2、如果所有的实例都包含一个共同的常量，则可以把这个常量设置成静态常量（static final 常量属性名 常量名）

7.3 静态方法：

1、静态方法不能使用this/super关键字
2、静态方法不能直接访问类的实例变量和实例方法
3、静态方法可以访问类的静态变量和静态方法（类名.静态变量，类名.静态方法()）

7.3 实例方法（通过实例访问）：

可通过实例直接访问类的静态方法、静态变量、实例方法、实例变量。