java的继承封装多态_Java中封装、继承、多态

1. Java中封装

封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。

隐藏类的实现细节，让使用者只能通过程序员规定的方法来访问数据，可以方便的加入存取控制语句，限制不合理操作。

1. 数据封装：保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接口访问。

2. 方法封装：方法的细节对用户是隐藏的，只要接口不变，内容的修改不会影响到外部的调用者。

public class Test {

public int add(int a, int b){

return a + b;

}

public void output(){

System.out.println("Hello World");

}

public void method(int a){

if(a < 10){

return;

}

System.out.println("Welcome!!");

}

public static void main(String[] args){

Test test = new Test();

int x = 8;

int y = 3;

int a = test.add(x, y);

System.out.println(a);

test.output();

int m = 15;

test.method(m);

}

}

11

Welcome!!

2. Java中继承

继承：继承是从已有的类中派生出新的类称为子类，子类继承父类的数据属性和行为，并能根据自己的需求扩展出新的行为。

通过extends关键字来实现，是实现代码重用的重要手段之一。Java是单继承，每个类只能有一个父类。所有类都是Object类的子类。

继承总结：

a) 父类有的，子类也有

b) 父类没有的，子类可以增加

c) 父类有的，子类可以改变

1. 属性

父类有，子类没有(父类调用父类的属性，子类调用父类的属性)

父类有，子类有(父类调用父类的属性，子类调用子类的属性)

父类没有，子类有(父类无法调用属性，子类调用子类的属性)

父类没有，子类没有(父类无法调用属性，子类无法调用属性)

(1) 父类有属性就用父类属性，没有就无法调用属性。

(2) 子类有属性就用子类属性，子类没有属性父类有就用父类的，子类没有属性父类也没有属性就无法调用属性。

2.方法

1) 构造方法(空)

父类有，子类没有(父类调用父类的构造方法，子类调用父类的构造方法、子类默认的构造方法)

父类有，子类有(父类调用父类的构造方法，子类调用父类、子类的构造方法)

父类没有，子类有(父类调用父类默认的构造方法，子类调用父类默认的构造方法、子类的构造方法)

父类没有，子类没有(父类调用父类默认的构造方法，子类调用父类默认的构造方法、子类默认的构造方法)

(1) 父类有构造方法就用父类的构造方法，没有就使用父类默认的构造方法。

(2) 父类有构造方法就用父类的构造方法，没有就使用父类默认的构造方法。子类有构造方法就用子类的构造方法，没有就使用子类默认的构造方法。

注意：这种情况是在没有其他构造方法的情况下。

2) 构造方法(非空)

3) 一般方法

父类有，子类没有(父类调用父类的一般方法，子类调用父类的一般方法)

父类有，子类有(父类调用父类的一般方法，子类调用子类的一般方法)

父类没有，子类有(父类无法调用一般方法，子类调用子类的一般方法)

父类没有，子类没有(父类无法调用一般方法，子类无法调用一般方法)

(1) 父类有属性就用父类一般方法，没有就无法调用一般方法。

(2) 子类有属性就用子类一般方法，子类没有属性父类有就用父类的，子类没有一般方法父类也没有一般方法就无法调用一般方法。

public class InheritenceTest {

public static void main(String[] args){

Dog dog = new Dog();

dog.run();

}

}

class Animal{

public void run(){

System.out.println("animal is running");

}

}

class Dog extends Animal{

public void run(){

System.out.println("dog is running");

super.run();

}

}

dog is running

animal is running

3. Java中多态

多态：指允许不同的对象对同一消息做出相应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

“一个接口，多种方法”，同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。重载(overload)和重写(override)是实现多态的两种主要方式。

多态的三个条件：

a) 继承的存在(继承是多态的基础,没有继承就没有多态)

b) 子类重写父类的方法(多态下调用子类重写的方法)

c) 父类引用变量指向子类对象(子类到父类的类型转换)

实现多态：

a) 接口多态性

b) 继承多态性

c) 通过抽象类实现的多态性

public class PolyTest {

public void run(Car car){

car.run();

}

public static void main(String[] args){

PolyTest test = new PolyTest();

Car car = new BMW();

test.run(car);

QQ qq = new QQ();

test.run(qq);

}

}

class Car{

public void run(){

System.out.println("car is running");

}

}

class BMW extends Car{

public void run(){

System.out.println("BMW is running");

}

}

class QQ extends Car{

public void run(){

System.out.println("QQ is running");

}

}

BMW is running

QQ is running

Java面向对象的三个特性：封装、继承、多态。(如果说四种就加一种：抽象)