封装继承多态一直以来是java的最基本功能，起着不可缺少的作用，小伙伴们知道该如何封装继承多态吗?在以下文章中，小编将会用几个例子，为你解答疑惑。

-----------------封装--------------

1、什么叫类

拥有相同属性和方法的很多很多的对象的集合，叫做类public class 类名

{

属性

方法

}

2、什么叫对象

实实在在存在的事物就叫做的对象

3、方法

一般方法分为两部分，方法原型和方法实现public void run()

{ //方法原型

System.out.println("我在跑步!"); //方法实现

}

关于方法原型：public 返回类型 方法名(参数列表)

4、属性

属性最大的问题的是，不能对赋值进行判断，所以需要封装

5、封装的好处

(1)对象的属性和方法是一个整体，不可分割

(2)保证数据安全性

(3)保证数据有效性 在方法加条件判断

6、如何进行封装：

属性的封装

1、将所有的属性加上private

2、为属性加上get/set方法

3、用set/get方法进行赋值取值

方法的封装

1、把方法名前面的public改为private

2、私有方法一定要在公共方法里面去调用

一般所有的属性都要私有，但是方法根据需要来私有

-------继承-------------

1、什么是继承?

子类继承父类，然后子类能自动拥有父类的一些属性和方法，这就是继承

2、为什么要用继承?

为了简化代码，所以我们需要用继承。相同的功能交给父类去实现，然后子类继承父类后能自动拥有这些功能，并实现功能扩展、多态

3、继承的语法?public class 子类 extends 父类

{}

public class 大学生

{

String name;

int age;

char sex;

public void 读书()

{}

}

public class 中学生

{

String name;

int age;

char sex;

public void 读书()

{}

}

public class 小学生

{

String name;

int age;

char sex;

public void 读书()

{}

}

学生中一种 is-a

把相同属性和方法放在父类中定义，然后让各个子类继承父类public class 学生

{

String name;

int age;

char sex;

public void 读书()

{}

}

public class 大学生 extends 学生

{

public void 读恋爱()

{}

}

public class 中学生 extends 学生

{

public void 上网()

{}

}

public class 小学生 extends 学生

{

public void 撒娇()

{}

}

四、子类能继承到什么?

父类的私有成员和方法;父类的构造;

除了这两个无法继承，其他都可以

五、哪些类可以继承

凡是满足“is-a”(xx是一种xx)关系的，都可以继承。

六、单继承和单方向

单方向：子类能继承父类，但父类不可以继承子类

单继承：一个子类只能有一个直接父类

七、Object

所有类的祖宗类

八、继承的原理

new 一个子类对象出来的时候，先造出父类对象，然后再生子类对象

儿子没有东西就会找父亲拿

九、super

创建子类时，会自动先调用父类的构造。子类调用父类构造使用关键字super。比如class A

{

public A()

{

System.out.println("A出生了");

}

}

class B extends A

{

public B()

{

super(); //这句代码就算不写，系统也会自动帮我们添上。一定保证先运行A的构造，再来运行B的构造

System.out.println("B出生了");

}

}

但如果我们在A里面自己写了个带参构造，那么无参的构造会自动消失。这时候请记得去子类修改构造class A

{

//自己写了个带参构造，那么不带参数的构造会自动消失

public A(int a)

{

System.out.println("A出生了");

}

}

class B extends A

{

public B(int a)

{

super(a); //为了避免子类构造报错，请自己手动调用带参的父类构造

System.out.println("B出生了");

}

}

自己调自己的构造用this()

子类调父类的构造用super()

--------------------------多态--------------------------------------

1、两种多态

方法重载：静态多态。方法相同，由于参数不同，产生不同的结果。

方法重写：动态多态。方法相同，由于执行不同，产生不同的结果。

重载，是同一个类调用的相同方法，根据不同条件产生出的不同结果;比如同一个厨师做饭，给的原材料不一样，能做出不一样的菜肴

重写，是不同类调用的相同方法，根据调用人的不同产生不不同结果;比如一家三兄弟都去洗衣服，有的可能手洗有的可能机洗

2、重写

同一个动作(方法名相同,参数相同，返回值类型相同)由不同的对象来做，结果不同

伏明霞.跳水(); //拿了世界冠军

青蛙.跳水(); //潜水

小猪.跳水(); //死了

大学生.消费(100);//买玫瑰送女友

小学生.消费(100);//存起来

中学生.消费(100);//上网,买东西吃

3、实现动态多态的步骤

得有继承

有方法的重写

有父类的引用指向子类对象

4、多态的实现:public class 父类

{

String name = "张三";

public void 睡觉()

{

System.out.println("父亲睡是躺着睡的");

}

public void 走路()

{}

}

public class 子类 extends 父类

{

String name = "李四";

int age = 10;

public void 睡觉()

{

System.out.println("儿子睡是侧着睡的");

}

public void 上网()

{}

}

a、属性无多态父类 father = new 子类();

System.out.println(father.name); //张三

b、方法有多态父类 father = new 子类();

father.睡觉(); //儿子睡是侧着睡的

c.子转父类,父类相同的方法会被子类覆盖,子类独有的方法会被隐藏父类 father = new 子类();

father.走路();

father.睡觉();

father.上网(); //错误 儿子转为父亲，儿子独有的属性或方法会被隐藏

System.out.println(father.name);

System.out.println(fahter.age); //错误

子类 son = (子类) father; //父转为子，儿子独有的属性或方法会恢复

son.上网();

System.out.println(son.age);

以上就是今天的全部内容了，相信你一定大有收获吧。如果还想了解更多java入门知识，就请持续关注奇Q工具网吧。

推荐阅读：

展开全部

多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中，接口的多种不同的实32313133353236313431303231363533e58685e5aeb931333366306538现方式即为多态。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，

父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作(摘自“Delphi4 编程技术内幕”)。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。

多态指同一个实体同时具有多种形式。它是面向对象程序设计(OOP)的一个重要特征。如果一个语言只支持类而不支持多态，只能说明它是基于对象的，而不是面向对象的。C++中的多态性具体体现在运行和编译两个方面。

运行时多态是动态多态，其具体引用的对象在运行时才能确定。编译时多态是静态多态，在编译时就可以确定对象使用的形式。

多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。

C++中，实现多态有以下方法：虚函数，抽象类，覆盖，模板(重载和多态无关)。

OC中的多态：不同对象对同一消息的不同响应.子类可以重写父类的方法

多态就是允许方法重名 参数或返回值可以是父类型传入或返回。

扩展资料：

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

赋值之后，父类型的引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲。

比如从某个基类派生出多个子类，其基类有一个虚方法Tdoit，然后其子类也有这个方法，但行为不同，然后这些子类对象中的任何一个可以赋给其基类对象的引用，或者说将子对象地址赋给基类指针，这样其基类的对象就可以执行不同的操作了。

实际上你是在通过其基类的引用来访问其子类对象的，你要做的就是一个赋值操作。

使用继承性的结果就是当创建了一个类的家族，在认识这个类的家族时，就是把子类的对象当作基类的对象，这种认识又叫作upcasting(向上转型)。这样认识的重要性在于：我们可以只针对基类写出一段程序，但它可以适应于这个类的家族，

因为编译器会自动找出合适的对象来执行操作。这种现象又称为多态性。而实现多态性的手段又叫称动态绑定(dynamic binding)。