JAVA入门三--面向对象（上）

面向对象的思想

面向过程：
分析出解决问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候依次调用就可以了。
面向对象：
把构成问题的事务按照一定规则划分为多个独立的对象，然后通过调用对象的方法来解决问题。
主要特点：封装性、继承性、多态性。

1. 封装性
   核心思想，两层含义：
   一、把对象的属性和行为看成一个密不可分的整体；
   二、“隐藏信息”，将不想让外界知道的信息隐藏起来。
2. 继承性
   类与类之间的关系。
   继承不仅增强了代码的复用性、提高了开发效率，还降低了程序产生错误的可能性，为程序的维护以及扩展提供了便利。
3. 多态性
   同一个属性和方法在不同的类中具有不同的语义。
   多态的特性使程序更抽象、便捷，有助于开发人员设计程序时分组协同开发。

类与对象

类和对象是Java中最基本、最重要的单元。
类表示某类群体的一些基本特征抽象；
对象表示一个个具体的事物。

1. 类的定义
   类是对象的抽象，用于描述一组对象的共同特征和行为。
   所有的Java程序都是基于类的。
   类中可以定义成员变量和成员方法。
   成员变量也称为是对象的属性；
   成员方法用于描述对象的行为，简称方法。

/*
	class 类名{
		成员变量；
		成员方法；
	}
*/

例如：

class Student{//定义一个类，Student是类名
	String name;//定义String类型的变量name（姓名）
	int age;//定义int类型的变量age（年龄）
	String Sex;//定义String类型的变量Sex（性别）
	void read() {//定义read()方法，直接访问对象属性
		System.out.println("大家好，我是"+name+",我在看书！");
	}
}

在Java中，定义在类中的变量被称为成员变量，定义在方法中的变量被称为局部变量。

3. 对象的创建与使用

/*
	类名 对象名称 = null;
	对象名称 = new 类名();
*/

/*
	类名 对象名称 = new 类名();

例如：

class Student{
	String name;       			 // 声明姓名属性
	void read() {  
		System.out.println("大家好，我是" + name + ",我在看书!");
	}
}
public class test {
	public static void main(String[] args) {
				Student stu = new Student(); //创建并实例化对象
		}

}

class Student{
	String name;
	void read() {
		System.out.println("大家好，我是"+name);
	}
}
public class test {
	public static void main(String[] args) {
		Student stu1 = new Student();
		Student stu2 = new Student(); 		// 创建第二个Student对象
		stu1.name = "小明";                 	// 为stu1对象的name属性赋值
		stu1.read();                  		// 调用对象的方法
		stu2.name = "小华";
		stu2.read();
	}

}

对象属性和方法的访问通过“.”运算符实现，具体格式如下：
对象名称.属性名
对象名称.方法名

5. 对象的引用与传递
   类属于引用数据类型，引用数据类型就是指内存空间可以同时被多个栈内存引用。
   一个栈内存空间只能指向一个堆内存空间，如果想要再指向其它堆内存空间，就必须先断开已有的指向才能分配新的指向。

例如：

class Student {
	String name;       	// 声明姓名属性
	int age;           		// 声明年龄属性
	void read() {  
		System.out.println("大家好，我是"+name+"，年龄"+age);
		}
 }
class Example02 {
	public static void main(String[] args) {
		Student stu1 = new Student (); //声明stu1对象并实例化
		Student stu2 = null;          //声明stu2对象，但不对其进行实例化
		stu2 = stu1;                       // stu1给stu2分配空间使用权。
		stu1.name = "小明";          // 为stu1对象的name属性赋值
		stu1.age = 20;
		stu2.age = 50;
		stu1.read();                  	  // 调用对象的方法
		stu2.read();
	}
}

对象引用传递的内存分配
stu1对象为stu2对象分配使用权，stu1和stu2指向同一内存。
stu1对象为属性赋值。

通过stu2修改age属性的值。

6. 访问控制
   针对类、成员方法和属性，Java提供了4种访问控制权限，分别是private、default、protected和public。
   
   4种访问控制权限，具体介绍如下。
   （1）private(当前类访问级别)：private属于私有访问权限，用于修饰类的属性和方法。类的成员一旦使用了private关键字修饰，则该成员只能在本类中进行访问。
   （2）default：如果一个类中的属性或方法没有任何的访问权限声明，则该属性或方法就是默认的访问权限，默认的访问权限可以被本包中的其它类访问，但是不能被其他包的类访问。
   （3）protected：属于受保护的访问权限。一个类中的成员使用了protected访问权限，则只能被本包及不同包的子类访问。
   （4）public：public属于公共访问权限。如果一个类中的成员使用了public访问权限，则该成员可以在所有类中被访问，不管是否在同一包中。
   

例如：

public class Test {
    public int aa;			//aa可以被所有的类访问
    protected boolean bb; 		//可以被所有子类以及本包的类使用
    void cc() { 			//default 访问权限，能在本包范围内使用
        System.out.println("包访问权限");
    }
    //private权限的内部类，即这是私有的内部类，只能在本类使用
    private class InnerClass {
    }
}

	如果一个Java源文件中定义的所有类都没有使用public修饰，那么这个Java源文件的文件名可以是一切合法的文件名；如果一个源文件中定义了一个public修饰的类，那么这个源文件的文件名必须与public修饰的类名相同。

构造方法

	构造方法（也被成为构造器）是类的一个特殊成员方法，在类实例化对象时自动调用。
	构造方法是一个特殊的成员方法，在定义时，有以下几点需要注意： 
		（1）构造方法的名称必须与类名一致。
		（2）构造方法名称前不能有任何返回值类型的声明。
		（3）不能在构造方法中使用return返回一个值，但是可以单独写return语句作为方法的结束。

例如：

class Student{
	public Student() {  
		System.out.println("调用了无参构造方法");
	}
}
public class Example05 {
	public static void main(String[] args) {
		System.out.println("声明对象...");
		Student stu = null;           	//声明对象
		System.out.println("实例化对象...");
		stu = new Student();     			//实例化对象
	}
}

	在一个类中除了定义无参的构造方法外，还可以定义有参的构造方法，通过有参的构造方法可以实现对属性的赋值。
	与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数或参数个数不同即可。
在创建对象时，可以通过调用不同的构造方法为不同的属性赋值。
	在Java中的每个类都至少有一个构造方法，如果在一个类中没有定义构造方法，系统会自动为这个类创建一个默认的构造方法，
这个默认的构造方法没有参数，方法体中没有任何代码，即什么也不做。
默认构造方法：

/*第一种写法：		
class Student {		
}	
第二种写法：	
class Student{			
	public Student(){
		｝
}
*/

this关键字

Java中的this关键字语法比较灵活，其主要作用主要有以下3种。
	（1）使用this关键字调用本类中的属性。
	（2）this关键字调用成员方法。
	（3）使用this关键字调用本类的构造方法。
在类的构造方法中，如果参数名称与类属性名称相同，则会导致成员变量和局部变量的名称冲突。

class Student {
	private String name;
	private int age;
	// 定义构造方法
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public String read(){
		return "我是:"+name+",年龄:"+age;
	}
}
public class Example10 {
	public static void main(String[] args) {
		Student stu = new Student("张三", 18);
		System.out.println(stu.read());
	}
}

通过this关键字调用成员方法的具体代码示例:

class Student {
	public void openMouth() {
		...
	}
	public void read() {
		this.openMouth();
	}
}

构造方法是在实例化对象时被Java虚拟机自动调用，在程序中不能像调用其他成员方法一样调用构造方法，但可以在一个构造方法中使用“this(参数1,参数2…)”的形式调用其他的构造方法。
在使用this调用类的构造方法时，应注意以下几点：
	（1）只能在构造方法中使用this调用其他的构造方法，不能在成员方法中通过this调用其他构造方法。
	（2）在构造方法中，使用this调用构造方法的语句必须位于第一行，且只能出现一次。
	（3）不能在一个类的两个构造方法中使用this互相调用。

代码块

	代码块，简单来讲，就是用“{}”括号括起来的一段代码，根据位置及声明关键字的不同，代码块可以分为4种：普通代码块、构造块、静态代码块、同步代码块。
	普通代码块就是直接在方法或是语句中定义的代码块。
	构造代码块是直接在类中定义的代码块。

static关键字

	如果希望某些属性被所有对象共享，就必须将其声明为static属性。
	如果属性使用了static关键字进行修饰，则该属性可以直接使用类名称进行调用。
	除了修饰属性，static关键字还可以修饰成员方法。
	如果在Java程序中使用static修饰属性，则该属性称为静态属性（也称全局属性），静态属性可以使用类名直接访问，访问方式如下：
	类名.属性名
	通过类名就可以直接调用某个方法，只需要在成员方法前加上static关键字，使用static关键字修饰的方法通常称为静态方法。
	同静态变量一样，静态方法也可以通过类名和对象访问，具体如下所示。
	类名.方法
	或
	实例对象名.方法
	静态方法只能访问静态成员，因为非静态成员需要先创建对象才能访问，即随着对象的创建，非静态成员才会分配内存。而静态方法在被调用时可以不创建任何对象。
	在Java类中，用static关键字修饰的代码块称为静态代码块。
	通常使用静态代码块对类的成员变量进行初始化。

class Student {
	String name;                          	// 定义name属性
	int age;                               	// 定义age属性
	static String school = "A大学";    	// 定义school属性
	public Student(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void info(){
		System.out.println("姓名:" +this. name+"，年龄:" +this.age+"，学校:" + school);  
	}
}
public class Example14 {
	public static void main(String[] args) {
		Student stu1 = new Student("张三",18);        // 创建学生对象
		Student stu2 = new Student("李四",19);
		Student stu3 = new Student("王五",20);
		stu1.school = "B大学";
		stu1.info();
		stu2.info();
		stu3.info();
	}
}

school属性修改前的内存
school属性修改后的内存