OOP_1部分

面向对象

对象和类

对象：软件中存在的单个个体
类：对象的模板，根据对象的属性抽取类的数据结构

定义类

定义成员变量

类的定义包括“成员变量”的定义和“方法”的定义，其中“成员变量”用于描述该类型对象共同的数据结构。

class 类名{
	成员变量类型 变量名称；
	......
}

对象创建后，其成员变量可以按照默认的方式初始化，默认的初始值为：

成员变量的类型	默认初始值
数值类型（byte、short、int、long、char、float、double）	0
boolean	false
引用类型	null

定义类的方法

方法用于描述对象的行为，封装对象。

class 类名{
	修饰词 返回值类型 方法名(参数列表){
		方法体......
	}
	......
}

创建并使用对象

创建对象

使用new关键字创建对象，创建对象的过程称之为实例化。
语法：

new 类名( );
eg: new Student( );创建了一个学生类对象

引用类型变量

-除8种基本类型之外，用类、接口、数组等声明的变量都称之为引用变量。

访问对象成员变量、调用方法

有一个WOW类

class WOW {
	//成员变量
	String name;
	int age;
	String address;
	String EnglishName;
	Student(String name,int age,String address,String EnglishName){	//局部变量
		this.name = name;	//把局部变量赋值给成员变量
		this.age = age;
		this.address = address;
		this.EnglishName = EnglishName;
	}
	//方法
	void study(){
		System.out.println(name+"是永远的大酋长!!!");
	}
	void sayHi(){
		System.out.println("我是"+name+",在"+address+"已经呆了"+age+"年了");
	}
	void say(){
		System.out.println("为了"+name+"!!!!For "+EnglishName+"!!!");
	}
}

可通过引用访问对象的成员变量或调用方法

	WOW w = new WOW("希尔瓦娜斯",10,"奥格瑞玛","Sylvanas");
	w.say();
	w.sayHi();
	w.study();

方法的重载和重写

重载

方法的重载发生在一个类中，两个方法的方法名相同，参数列表和方法体不同

重写

方法发生在派生类中，方法的方法名相同和参数列表相同，方法体不同

构造方法

每个类都存在构造方法，可以被重载。

语法结构

定义规则：

• 构造方法的名称必须与类相等
• 构造方法没有返回值，但也不能写void

语法：

[访问修饰类] 类名( ){
//构造方法体
}

初始化成员变量

构造方法常常用于实现对象成员变量的初始化。

this

this关键字在方法体中，用于指向调用该方法的当前对象。
一般方法的参数中定义了与类中重名的变量，方法体中的变量表示的是参数变量，加上this表示的是类中的成员变量，例如：

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

super

super关键字的作用是用于子类引用父类的成员，如属性、方法或者构造器。

• 调用父类构造器
  直接用super()加上父类构造器所需要的参数，就可以调用父类的构造器了。如果父类中有多个构造器，系统自动根据super()中参数个数和参数类型类匹配父类中的构造器。
• 调用父类方法、属性
  super.属性
  super.方法([arg_list])
  注意，在这个时候，父类的属性或方法必须是那些protected或者public等可以让子类访问的属性或者方法。

默认的构造方法

• 任何一个类都必须含有构造方法；
• 若源程序没有定义构造方法，编译期在编译时将自动添加一个无参构造（默认的构造方法）；
• 定义了构造方法后，java编译期将不会再次添加默认的构造方法。
  

构造方法的重载

一个类可以定义多个构造方法，一个构造方法可以通过this关键字调用另外一个重载的构造方法

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

public Student(){
	this("无名氏"，1)；
}

数组

引用类型数组的声明

• 数组的元素可以是任何类型，当然也可以包括引用类型。
• 例如：Airplane[ ] as = new Airplane[4];
  

引用类型数组的初始化

• 引用类型数组的默认初始值都是null
• 若希望每一个元素都指向具体的对象，需要对每一个数组元素进行“new”运算。

Airplane[] as = new AirPlane[4];
as[0] = new Airplane();
as[1] = new Airplane();
as[2] = new Airplane();
as[3] = new Airplane();

Airplane[] as = {	new Airplane(),
					new Airplane(),
					new Airplane(),
					new Airplane()
					};

继承

提高代码复用性

泛化的过程

extends关键字

• 通过extends关键字可以实现类的继承；
• 派生类（子类）可以继承超类（父类）的成员变量及成员方法，同时也可以定义自己的成员变量和成员方法；
• java语言不支持多重继承，一个类只能继承一个超类，但一个超类可以有多个派生类。

public class Person{
	String name;
	int age;
	String address;
	void sayHi(){
		System.out.println("你好，我叫"+name+"，今年"+age+"岁了，家住"+address};
}

public class Student extends Person{
	String classname;
	void study(){}
}

public class Teacher extends Person{
	int salary;
	void teach(){}
}

继承构造方法

• 派生类（子类）的构造方法中必须通过super关键字调用超类构造方法。
• 若派生类（子类）的构造方法中没有调用超类（父类）的构造方法，java编译期会自动加入对超类无参构造方法的调用（若该超类没有无参的构造方法，会发生编译错误）

public Student{
	super();//编译期自动添加
	......
}//super关键字必须位于派生类构造方法的第一行

class Foo{
	int value;
	Foo(int value){
		this.value = value;
	}
}

class Goo entends Foo{
	int num;
	Goo(int value, int num){
		super(value);//调用超类构造方法并初始化
		this.num = num;
	}
}

超类的引用指向派生类的对象

• 一个派生类的对象可以向上造型为超类的类型，即定义超类型的引用可以指向派生类的对象。
  
• 父类的引用可以只想子类的对象，但通过父类的引用只能访问父类所定义的成员，不能访问子类扩展的部分
  

方法的重写

• 子类可以重写（覆盖）继承自父类的方法，即方法名和参数列表与父类的方法相同，但方法的实现不同。
• 当子类对象的重写方法被调用时（无论是通过子类还是父类的引用调用），运行的是子类的重写后的版本。
  
• 子类在重写父类的方法时，可以通过super关键字调用父类的版本。
  

重写和重载的区别

• 重载是指在一个类中定义多个方法名相同但参数列表不同的方法，它遵循所谓”编译期绑定“，即在编译时根据参数变量的类型判断应该调用哪个方法。
• 重写是指在子类中定义和父类参数列表和方法名相同的方法，它遵循所谓”运行期绑定“，即在运行时根据引用变量指向的实际对象类型调用方法。

访问控制

public、private、protected和默认访问控制符

• private修饰的成员变量和方法仅仅只能在本类中调用；
• public修饰的成员变量和方法可以在任何地方调用；
• protected修饰的成员变量和方法可以被子类及同一个包中的类使用；
• 默认访问控制即不书写任何访问控制符，默认访问控制的成员变量和方法可以被同一个包中的类调用。
  

final

final修饰变量

• final关键字修饰变量，意为不可改变
• final修饰成员变量，两种方式初始化：
  – 声明同时初始化
  – 构造函数中初始化
• final关键字也可以修饰局部变量，使用之前初始化即可。

public class Emp{
	private final int no = 100;//final变量声明时初始化
	public void testFinal(){
		no = 99;
	}//编译错误，final的变量不可被改变
}

final修饰方法

• final关键字修饰的方法不可以被重写。
• 使一个方法不能被重写的意义在于：防止子类在定义新方法时造成的“不经意”重写。

final修饰类

• final关键字修饰的类不可以被继承；
• JDK中的一些基础类库被定义为final的，例如：String、Math、Integer、Double等等；
• 使一个类不能被继承的意义在于：可以保护类不被继承修改，可以控制滥用继承对系统造成的危害。

final、finally和finalize的区别

final:

• 修饰的变量不能被更改
• 修饰的方法不可被重写
• 修饰的类不可被继承

finally:

finally在java项目中大多是用于对资源关闭的处理，请记住，无论是否发生异常，资源都必须进行关闭。

finalize

finalize()是Object中的方法，当垃圾回收器将要回收对象所占内存之前被调用，即当一个对象被虚拟机宣告死亡时会先调用它finalize()方法，让此对象处理它生前的最后事情（这个对象可以趁这个时机挣脱死亡的命运）。