JAVA面向对象内容概述2

01、面向对象三大特征之–封装

封装是把过程和数据封闭起来以避免外界直接访间，外界只能通过已定义的接口实现对数据的访间。封装是一种信息隐藏技术，在Java中通过关键字private实现封装。简单地说，封装实际上是将类的数据隐藏起来，并使用方法来控制用户对类的修改和访问数据的程度。
封装的优点在于它可以隐藏私有数据，让使用者只能通过公共的访问方法来访问这些字段。只需要在这些方法中增加逻辑控制，限制对数据的不合理访问，就能方便数据检查，对象信息的完整性。另外，封装还便于修改代码，提高代码的可维护性。
例：

public static void main(String[] args) {
	Dog d1 = new Student();
	d1.setName("张三");
	d1.setAge(200);//学生的年龄赋值很明显不合理，这里就需要在set方法中给出提示
	}
}
class Student{
	private String age;
	private String name;
	public void setAge(int age) {
		if(age>100||age<0) {
			System.out.println("你见过超过200岁的学生吗？");
		}else  {
			this.age = String.valueOf(age);
		}
		
	}
	public void setName(String name) {
		this.name = name;
	}
}		

02、面向对象三大特征之–继承

简单地说，继承就是子类继承父类的特征和行为,使得子类对象具有父类的特征，或子类从父类继承方法，使得子类具有父类相同的行为。继承的实现extends关键字继承是面向对象的重要概念。是除组合之外,提高代码重复可用性的另一种重要方式。继承的主要作用在于在已有基础上(父类已经定义好)继续进行功能的扩充。
1、被继承的类称为父类（超类），继承父类的类称为子类（派生类）使用 关键字extends 继承。
2、子类拥有父类非 private 的属性、方法。
3、子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
4、子类可以用自己的方式实现父类的方法（即方法的重写/覆盖）。
5、构造器而言，它只能够被调用，而不能被继承，子类可以使用super()调用父类构造器。
6、对于继承而已，子类会默认调用父类的无参构造，但是如果父类没有无参构造，子类必须要在其构造方法中的第一行代码调用指定父类的构造器，传递对应参数。
7、Java 的继承是单继承，但是可以多重继承，即子类只能拥有一个直接父类，但是该父类仍然可以作为其他类的子类。
例：

class Father{
	//父类中的非私有属性都会被继承
	public int age;
	private double money;
	String name;
	//父类中的非私有方法都会被继承
	void eat() {} //吃饭
	public void study() {}//学习
	private void game() {}//打游戏
	//父类构造方法如果有参数，子类必须在构造方法第一行中调用
	public Father(int x) {
		//父类如果写了有参构造，那么默认的无参构造将不再生效
	}
}
class Son extends Father{
	public Son(int x) {
	}
		super(x);//调用父类构造 super() 
		age=20;//继承后拥有父类的属性
		name="张三";
		//money=3.0; 父类私有属性无法访问
		study();//可以执行父类中的非私有方法
	}

03、面向对象三大特征之–多态

多态指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。简单来说就是不同类型的对象（父类或子类）调用同一个方法，根据发出调用的对象不同，执行的方法也就不同。
在JAVA中有两种类型的多态：编译时的多态性和运行时的多态性。我们可以通过方法覆盖和方法重载执行。
覆盖发生在父类和子类之间。当发现继承自父类的成员变量或方法不满足自己的要求时,就会对其重新定义。当子类的成员变量与父类的成员变量同名时(声明的类型可以不同)，子类的成员变量会隐藏父类的成员变量：当子类的方法与父类的方法具有相同的名字、参数列表、返回值类型时,子类的方法就会重写父类的方法(也叫作方法的覆盖)。方法的覆盖是动态多态性的表现，即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
方法的重载是指在一个类中多个重名的方法，但是要求每个方法具有不同的参数类型或参数个数。调用重载方法时，Java编译器能通过检查调用的方法的参数类型和择一个恰当的方法。方法重载通常用于创建完成一组任务相似但参数类型或参数个数顺序不同的方法。也就是说，Java的方法重载，就是在类中可以创建多个方法，它们可以有相同的名字，但必须具有不同的参数，或者具有的参数个数不同，或者是参数类型不同。
例：

public class People {//人类 作为所有职业的父类
	public int age;
	public String name;
	void work() {//父类的方法
		System.out.println("工作");
	}
}
class Teather extends People{
	void work() {//教师类继承人类，重写工作方法
		System.out.println("教书育人");
	}
	
}
class Teacher extends People{
	void work() {//教师类继承人类，重写工作方法
		System.out.println("教书育人");
	}
}
public static void main(String[] args) {
		//父类引用指向子类对象就是多态性的体现
		People p1 = new Teather();// p1的类型是人类类型，但是指向的实例对象是教师
		People p=new People();
		p.work();//父类
		p1.work();//父类引用发出的调用，调用到的是教师类中重写父类的方法
	}

运行结果

工作
教书育人

04、super关键字的作用

super关键字可以理解为对父类的引用,super可以完成以下的操作：
1、使用super调用父类中的属性，可以从父类处获得信息。
2、使用super调用父类中的方法，在子类中执行。
3、使用super调用父类中的构造方法（super(实参)形式），必须在子类构造方法的第一条语句，调用父类中相应的构造方法，若不显示的写出来，默认调用父类的无参构造方法，比如：super();
例：

class F {
	public int age;
	public String name;
	void m1() {
		System.out.println("父类方法");
	}
	public F(int age) {
		System.out.println("父类有参构造");
	}
	public F(){
		System.out.println("父类无参构造");
	}
}
class Z extends F{
	public Z() {
		super();//调用父类构造，若不写这行代码也会默认调用父类的无参构造
		//若是调用父类有参构造，则需要传递对应类型的参数
		super.age=30;//调用父类属性
		super.m1();//调用父类方法
	}
}

05、final关键字的作用

有一些类，在定义的时候就被设置为只能让使用者直接使用该类里面的功能，而不能被继承，这种类就是最终类。最终类用关键字final修饰。所以，被final修饰的类不能被继承，不能作为其他类的父类，典型代表就是String类。String类只能让我们直接使用该类里面的功能。

06、抽象类

在Java中，用abstract关键字来修饰一个类时，这个类叫作抽象类。抽象类是它的所有子类的公共属性的集合，是包含一个或多个抽象方法的类。抽象类可以看作是对类的进一步抽象。
在面向对象领域，抽象类主要用来进行类型隐藏，不能创建抽象类的实例。在抽象类中包含一般方法和抽象方法。
抽象方法的定义与一般方法不同，抽象方法在方法头后直接跟分号，而一般方法含有以大括号框住的方法体。所有的抽象方法必须存在于抽象类中，这些方法只有方法头的声明，用一个分号来代替方法体的定义，即只定义成员方法的接口形式，而没有具体操作。
例：

public abstract class People {
	//由abstract修饰符修饰的类就是抽象类
	abstract void work();
	//由abstract修饰符修饰的方法就是抽象方法，没有具体的方法执行，即方法体{}
}
class Doctor extends People{
// 非抽象的子类继承抽象父类，必须重写父类中的抽象方法
	@Override
	void work() {//子类重写的方法必须有方法执行体{}
		System.out.println("救死扶伤");
	}

只有派生类对抽象成员方法的重定义才能真正实现与该派生类相关的操作。在各子类继承了父类的抽象方法之后，再分别用不同的语句和方法体来重新定义它，形成若干个名字相同、返回值相同、参数列表相同、目的一致但是具体实现有一定差别的方法。
抽象类中定义抽象方法的目的是实现一个接口，即所有的子类对外都呈现一个相同名字的方法。
例：

public static void main(String[] args) {
		//People p1 =new People();//编译错误，抽象类不能实例化
		People p2 = new Doctor();//编译正确

07、接口

接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法(抽象方法)，否则就必须声明为抽象类。
当有两个及以上的类拥有相同的方法，但是实现功能不一样时,可以定义一个接口,将这个方法提炼出来，在需要使用该方法的类中去实现，从而免除多个类定义系统方法的麻烦。
例：

public interface Weapon {//声明一个接口
	int HP=100;//接口中定义的变量就是静态常量
	
	void kill();//接口中定义的方法就是抽象方法
	 //当不定义返回值类型时默认public
	//private void m1();//接口中不能定义私有抽象方法，没有意义
	//private int MP=100;//接口中不能定义私有属性
	static void m2() { //接口中可以有具体的方法，必须声明为static或者default
		System.out.println("物理攻击");
	}
 
}

接口的使用规则：
1、定义一个接口，使用interface关键字
2、在一个接口中，只能定义常量、抽象方法，JDK1.8后可以定义默认的实现方法
3、接口可以继承多个接口：extends xxx,xxx

抽象类和接口比较：
抽象类表示该类中可能已经有一些方法的具体定义，但是接口就仅仅只能定义各个方法的界面(方法名，参数列表，返回类型)，并不关心具体细节。
接口是引用类型的，和抽象类的相似之处有三点:
1、不能实例化;
2、包含未实现的方法声明;
3、派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员(不仅是方法包括其他成员)。
抽象类与接口紧密相关。然而接口又比抽象类更抽象，这主要体现在它们的差别上:
类可以实现无限个接口，但仅能从一个抽象(或任何其他类型)类继承，从抽象类派生的类仍可实现接口，从而得出接口是用来解决多重继承问题的。
抽象类当中可以存在非抽象的方法，可接口不能，且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。
抽象类中的成员变量可以被不同的修饰符来修饰，可接口中的成员变量默认的都是静态常量。
抽象类是对象的抽象，然而接口是一种行为规范。