JAVASE总结--08（封装、继承、多态）

面向对象的三大特征
1.封装/隐藏
隐藏内部复杂的代码，只暴露出简单的
 
高内聚，低耦合
高内聚：类的内部数据操作细节自己完成，不允许外部干涉（对外部的依赖越小，     意味着程序越健壮）
低耦合：尽量少的暴露方法给外部（程序外部）使用
public ----------------------------------所有的类
default
（默认/缺省）
--------同一个包
private -------------------------------同一个类
protected----------------------------子类/子类的子类
2.继承
extends
Java通过继承机制很好地实现了类的可重用性和扩展性。（类的派生）
父类/超类
子类
在JAVA中，一个类只能继承一个父类，称为单继承。但一个父类却可以派生出多个子类，每个子类又可以作为父类派生出多个子类。
子类定义的格式：
【修饰符】
class 子类名 extends
父类名{
      
属性成员的定义；
      
方法成员的定义；
}
 
提高代码的复用性，对类进行抽象，实现对现实世界更好的建模
子类继承父类可以获取所有的属性和方法（除了构造方法）
在java中如果当前类没有写extends，默认继承object
所有类的根基类都是object，object中的方法在所有类中都有
子类的权限不能比父类权限更严格
当子类继承父类的时候，会继承到父类所有的属性和方法，包含私有的，但不能用。
override
方法的重写
重写的前提是要有继承
方法名称，返回值类型，参数列表 必须相同
super
如果需要调用父类的方法，super
普通方法中
调用直接父类的方法
可以调用多次
无顺序限制
构造方法中
调用直接父类的构造器
只能调用一次
必须放在第一行（否则默认为super（），调用直接父类的空参数构造器，当父类没有空构造器时，报错）
创建对象的时候，永远都是先创建父类，创建完毕之后再创建子类
一个子类里面就包含了它的所有父类，它会把整个继承链的对象都创建一次。
static静态代码块
执行顺序
上溯到object类，先执行object的静态初始化块，再向下执行子类的静 态初始化块，直到我们的类的静态初始化块为止。执行完静态之后执行当
前非静态代码块，当前默认有super（），所以仍然是从上到下 执行
代码：
package com.bjsxt.ly;

public class TestStatic {

public static void main(String[]
args) {

System.out.println(new Ccc().toString());

}

}

class Aaa {

static {

System.out.println("Aaa.enclosing_method(1)");

}

public Aaa() {

super();

System.out.println("Aaa.Aaa(2)");

}

}

class Bbb
extends Aaa {

static {

System.out.println("Bbb.enclosing_method(3)");

}

public Bbb() {

super();

System.out.println("Bbb.Bbb(4)");

}

}

class Ccc extends Bbb
{

static {

System.out.println("Ccc.enclosing_method(5)");

}

public Ccc() {

super();

System.out.println("Ccc.Ccc(6)");

}

}
执行结果：
Aaa.enclosing_method(1)

Bbb.enclosing_method(3)

Ccc.enclosing_method(5)

Aaa.Aaa(2)

Bbb.Bbb(4)

Ccc.Ccc(6)

com.bjsxt.ly.Ccc@1db9742
 
 
 
3.多态polymorphism
多态性是OOP中的一个重要特性，主要是用来实现动态联编的，换句话说，就是程序的最终状态只有在执行过程中才被决定而非编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。
定义变量时，定义一个父类，实现时传入子类
在java中，多态性体现在两个方面：
由方法重载实现的静态多态性（编译时多态）
方法重写实现的动态多态性（运行时多态）
多态存在的三个必要条件：
要有继承、要有方法重写、父类引用指向子类对象
向上转型
子类变父类（麻雀是鸟）
因为子类中默认有一个父类，而且调用方法的时候优先子类所拥有的
向下转型（强制转换）
前提是父类本来就是向上转型过来的，才可以向下转回去
代码：
package com.bjsxt.lh;

 

public class TestPoly4 {

public static void main(String[]
args) {

Person person =
new Person();

Auto auto =
new Auto();

Audi audi =
new Audi();

Bmw bmw =
new Bmw();

 

//com.bjsxt.lh.Car cannot be cast to com.bjsxt.lh.Bmw

//Bmw bmw2 = (Bmw) new Car();

//父类能转成子类，说白了就是因为本来父类就指向了一个子类

//Car car = new
Bmw();

（父类的声明，子类的空间）

//car.run();

//Bmw bbb = (Bmw) car;

//bbb.run();

//虽然父类指向子类，但是向下转型的时候类型不一致

//Car car = new Auto();

//Bmw www = (Bmw) car;

 

person.driver(audi);

}

}

 

class Person {

 

public void driver(Car
car) {

car.run();

}

}

 

class Car {

public void run() {

System.out.println("Car.run(我是轿车)");

}

}

 

class Auto
extends Car {

public void run() {

System.out.println("Auto.run(不要欺负我，我哥哥是奥迪)");

}

}

 

class Audi
extends Car {

public void run() {

System.out.println("Audi.run(不要欺负我，我哥哥是奥运)");

}

}

 

class Bmw
extends Car {

public void run() {

System.out.println("Audi.run(不要欺负我，我哥哥是奥巴马)");

}

}

package com.bjsxt.ly;

/**

 * a1普通的A

 * show(D)

 * show(A)

 * a2   B的向上转型

 * show(a)ba

 * show(d)ad

 * b普通的B

 * show(b)

 * show(a)

 * show(d)

 * c普通的C

 *

 * d普通的D

 */

public class TestAbc {

public static void main(String[]
args) {

A a1 =
new A();

A a2 =
new B();

B b =
new B();

C c =
new C();

D d =
new D();

System.out.println("1" +
a1.show(b));//aa

System.out.println("2" +
a1.show(c));//aa

System.out.println("3" +
a1.show(d));//ad

 

System.out.println("4" +
a2.show(b));//ba

System.out.println("5" +
a2.show(c));//ba

System.out.println("6" +
a2.show(d));//ad

 

System.out.println("7" +
b.show(b));//bb

System.out.println("8" +
b.show(c));//bb

System.out.println("9" +
b.show(d));//ad

 

System.out.println("10" +
c.show(d));//ad

System.out.println("11" +
c.show(a1));//ba

System.out.println("12" +
c.show(a2));//ba

System.out.println("12" +
c.show(b));//bb

}

}

 

class A {

public String show(D
obj) {

return ("A and D");

}

public String show(A
obj) {

return ("A and A");

}

}

class B
extends A {

public String show(B
obj) {

return ("B and B");

}

@Override

public String show(A
obj) {

return ("B and A");

}

}

 

class C
extends B {

}

class D
extends B {

}
Animal a=new Cat();
    一、使用父类类型的引用指向子类的对象；
    二、该引用只能调用父类中定义的方法和变量；
    三、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）（动态绑定是指”在执行期间（而非编译期间）“判断所引用对象的实际类型，根据实际的类型调用其相应的方法）
优先调用当前类，当前类找不到时向父类找
final
最后的，最终的，决定性的、不可更改的
变量（常量）
成员变量
首先需要被赋值（声明的时候赋值，构造器中赋值），而且不能够进行修改
局部变量
使用之前需要先赋值，而且只能赋值一次
方法
被final的方法我们不能重写，但是可以重载
类
被final修饰的类不能被继承，但是可以继承其他类