CoreJava学习笔记4

面向对象的三大特征：封装、继承、多态

Java中的封装

封装，一个对象和外界的联系应当通过一个统一的接口。
对象中的内容应当公开的公开，应当隐藏的隐藏。（对象的属性应当隐藏）
一个对象的内部是透明的，把对象内部的可透明性和隐藏的特性区分开，该透明的透明，该隐藏的隐藏。

属性的封装，java中类的属性的默认访问权限不是private，是default，不加访问权限修饰符的属性和方法默认为default。
隐藏该属性或方法，要加private（私有）修饰符，限制只能在类的内部进行访问。属性一般都作成私有private
对于类中的私有属性，要对其给出一对方法（getXxx(),setXxx()）访问私有属性，保证对私有属性的操作的安全性。

方法的封装，对于方法的封装，该公开的公开，该隐藏的隐藏。方法公开的是方法的声明（定义），即（只须知道参数和返回值就可以调用该方法），隐藏方法的实现会使实现的改变对架构的影响最小化。

封装的意义，封装会使方法实现的改变对架构的影响最小化。

完全封装，类的属性全部私有化，并且提供一对方法来访问属性。

例：

public class Person{
	private int age;//属性的封装
	private String name;
	public String getName(){
		return name;
	}
	public void setName(String name){
        this.name=name; //this是一个关键字，他代表的是当前对象
         //这一句的意思就是为本对象的属性name进行赋值               
    }
	public int getAge(){//方法的封装
		return age;
}
private String nickname(){//方法的封装
	……
}
public void setAge(int age){
	this.age=age
}

}

java中的继承

继承，是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父类。父类的意义在于可以抽取多类事物的共性。

java中的继承要使用extends关键字，java中只允许单继承，一个类只能有一个父类。
这样继承关系呈树状，体现了java的简单性。

子类只能继承在父类中可以访问的属性和方法（父类中私有的属性和方法会被继承但子类中但无法访问罢了）。

访问控制修饰符:（可以修饰属性和方法）
private修饰符，表示只有本类内部可以访问。
default修饰符，方法不加修饰符，默认为default，表示在同一个包中可以访问，父子类在同一包中，子类可以继承父类的相应内容。（可以修饰类）
protected（保护）修饰符，表示同一包中可以访问，不同包的子类也可以访问继承。
public修饰符，表示公开，在任何地方都可以访问。（可以修饰类）
修饰符的权限是由上而下逐渐变宽的。

继承的意义，子类可以在父类的基础之上对父类的功能进行发展,继承使系统的耦合性降低，使对象间的联系变得松散，使多类对象间的联系可用其父类对象代替。

注意：构造方法不能被继承。

父类的属性及方法的确定：从子类的角度来看子类间的共性，所有子类都有这个属性时，应当考虑是否该放在父类中。
方法可以看作是对象的行为，类的方法是这一类的对象所共有的行为，所以应当在方法的确定时，注意是不是所有的子类型中都需要有这个方法，根据不同的子类型的该方法的不同，才覆盖这个方法。

java中方法的覆盖

子类中有和父类中可访问（可继承到子类）的同名、同返回值类型、同参数表的方法，才是覆盖了从父类继承来的方法。

注意：覆盖父类中的某个方法，子类中写的方法要和父类中的方法名、参数表、返回值类型，都相同的，权限访问修饰符比父类的方法的权限修饰符的权限要么相同，要么更宽。

注意：在jdk1.4以前要求方法的覆盖时，需要方法的返回值，参数表，方法名必须严格相同，而在jdk1.5中方法覆盖，子类的中覆盖的方法的返回值可以是父类中被覆盖的方法的返回值类型的子类型。

注意：子类覆盖父类的方法时，方法的修饰符要么相同，要么子类中的方法的修饰符表示的访问权限要宽于父类。父类中的私有方法，不能被继承到子类，子类中即使将其覆盖了也不会有多态。

覆盖的意义：对从父类中继承的方法的发展。

注意：父子类中有同名的属性不叫子类覆盖了父类的属性，这种情况较作属性的遮盖（shadow）。

例：

public class Person{
	……
	private int age;
	public void study(){
		System.out.println(“学习”);
	}
}
class Child extends Person{
	private int age;//属性的遮盖
	public void study(){//覆盖了父类中的study（）方法
		System.out.println(“在小学学习”);
	}
}
public class Test{
	static public void main(String[] args){
		Person p=new Child();
		p.study();
	}
}

当构造有继承关系的对象的步骤
1，递归的构造父类的对象
2，分配空间
3，初始化本类实例变量（属性）
4，调用本类的构造方法

注意：子类对象中包含着父类的对象，父类对象加上子类对象，才是完整的子类对象的实例。在构造子类对象时，先递归的构造父类对象，会默认的调用父类的无参的构造方法，所以最好将类中无参构造方法写上。

super关键字

super()，表示在子类的构造方法中调用父类的构造方法（可以通过这种方法在子类的构造方法中初始化父类中的属性），super()只能出现在构造方法的第一句上。super(),在子类的构造方中指明构造父类时调用哪一个父类的构造方法构造父类。

super,表示一个父类的对象，可以通过super来使用父类中可以访问的方法（可以在父类中定义setXxx()，getXxx()方法来访问父类中的私有属性），super可以屏蔽父子类中同名属性的命名冲突。
例：

public class Person{
	……
	private int age;
	private String name;
	public Person(){
	}
	public Person(String name){
		this.name=name;
    }
	public void study(){
		System.out.println(“学习”);
	}
}
class Child extends Person{
	private int age;//属性的遮盖
	public Child(String name){
		spuer(name);//调用父类的构造方法初始化父类的属性
	}
public void study(){//覆盖了父类中的study（）方法
		System.out.println(spuer.getName（）+“在小学学习”);
        //super.getName()也就是调用了父类的访法
	}
}

注意：构造方法的第一句既不是this(),也不是super()时，会隐含的调用其父类的无参的构造方法，即隐含的有super()，在写类的时候，一定要写无参的构造方法。

少覆盖原则：既子类应当尽量少的覆盖父类方法，如果覆盖了父类的大多数方法，那就应当考虑是否应当有继承关系

java中的多态（以子类覆盖了父类的方法为前提）

多态，把子类对象主观的看作是其父类型的对象，那么父类型就可以是很多种类型。

多态，编译时多态（方法的重载）
      运行时多态（多态）

编译时类型，也就是可以被看作的类型，主观认定。
运行时类型，也就是实际的对象实例的类型，客观不可改变（也是被看作类型的子类型）

在对象产生时，运行时类型就已经确定不会改变，编译时类型可以和运行时类型不同。
对象引用声明并赋值后，就确定了其运行时类型。
编译时类型对象引用背后所指向运行时类型可以是其类型或者是其子类型。

多态三特性
1，对象实例确定则不可改变（客观不可改变）
2，只能调用编译时类型所定义的方法。
3，运行时会根据运行时类型去调用相应类型中定义的方法。

多态的意义：在需要使用一类对象的共性时，可以用多来屏蔽掉其子类中的差异。

注意：类的属性是没有多态的，会根据编译时类型访问。
子类覆盖了父类的方法，把子类对象实例赋值给父类类型的对象因用时才会有多态。
要注意区分子类中的方法重载。
对于方法的重载，会使用编译时类型来进行相应的方法调用。

instanceof，是用于判断一个对象是否属于某个类型

例
public class Animal{
	……
	public void eat(){
		System.out.println(“eat sth”);
	}
	public static void main(String[] args){
		Animal a=new Dog();
		Animal b=new Cat();
		if（b instanceof Dog）{
			Dog d=（Dog）b
		}
        /*
Animal是编译时类型，并且是实际类型的父类，所以
多态优两个前提，父子类关系，还有方法的覆盖
*/
a.eat();
b.eat();
	}
}
class Dog extends Animal{
	public void eat(){
		System.out.println(“eat bones”);
	}
}
class Cat extends Animal{
	public void eat(){
		System.out.println(“eat fishs”);
	}
}

结果：
eat bones
eat fishs

//这里之所以显示的是子类中方法结果，就是由于多态，根据其实际类型调用子类的方法

例：

两种代码复用

白箱复用，继承复用，父类中的可以被子类访问到的就可以被继承，会有些不需要的内容被继承，这种方式不太好。

黑箱复用，组合复用，把要复用代码的类的对象作为本类的属性，通过方法的委托来实现有选择的复用，方法的委托是在本类的方法内部通过该类的对象调用要使用的方法。

注意：尽量用组合复用替代继承复用。

例：

public class Car(){
	……
}

class Benz{
	Car c=new Car();
	……
}

多态的使用

多态用于参数，在方法的参数中传入其父类类型，在运行时会根据实际的运行时类型来在方法中进行相应的操作。
多态用于返回值，在方法的返回值类型上是用其实际返回值的父类型，在使用其返回值时也不必关心其实际类型。

多态使代码变得更通用，以适应需求的变化。定义在父类中的方法，可以在子类中有不同的实现将其覆盖，在为父类型的对象引用赋值相应需要功能的子类的对象实例。
例：

public class TestCar{
	public static void main(String[] args){
	    CarFactory cf=new CarFactory();
		Car c1=cf.createCar(1);
		Car c2=cf.createCar(0);
		c1.run();
		c2.run();
        cf.testCar(c2);
		cf.testCar(c1);
}
}

public class CarFactory{
	public Car createCar(int a){//多态用作返回值类型
		if(a==1){
			return new BenzCar();
        }else {
            return new BMWCar();
}
	}
	public void testCar(Car c){//多态用作方法的参数
		c.test();
	}
}
class Car{
	public void run(){
	}
	public void test(){
	}
}

class BenzCar extends Car{
	public void run(){
		System.out.println(“BenzCar is running”);
}
public void test(){
	System.out.println(“BenzCar is much better”);
}
}

class BMWCar extends Car{
	public void run(){
		System.out.println(“BMW is running”);
	}
public void test(){
System.out.println(“what a buttiful BMWCar! ”);
}
}

结果：
BenzCar is much better
BMW is running
what a buttiful BMWCar!
BenzCar is much better