「java封装继承是什么」java封装和继承

今天给各位分享java封装继承是什么的知识，其中也会对java封装和继承进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java封装继承
• 2、java中的继承是什么
• 3、什么是Java的封装继承和多态？在线等！！！！
• 4、java里面的面向对象编程有关于封装继承通俗讲是什么意思
• 5、先谢谢了！java里封装、继承、抽象、多态分别是什么意思？请帮我解释的人性化点！
• 6、java面向对象，封装继承多态的定义

java封装继承

一、封装(encapsulation)

封装性就是把类（对象）的属性和行为结合成一个独立的相同单位，并尽可能隐蔽类（对象）的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。封装的特性使得类（对象）以外的部分不能随意存取类（对象）的内部数据（属性），保证了程序和数据不受外部干扰且不被误用。

这个怎么理解呢？首先来看一个列子。

已知一个类Animal，该类的属性和方法如下表所示：

属性

说明

方法

说明

String name

名称

Animal()

无参构造函数，为属性设置初始值

Int age

年龄

Animal(String name,int age)

有参构造函数，为属性设置变量值

根据该类的定义，编写一个程序，输出该类的初始值以及通过变量设置的初始值，程序代码如下

public class AnimalDemo{

public static void main(Stringargs[]){

Animal a=new Animal();

Animal b=new Animal("cat",5);

System.out.println(a.name+"is "+a.age+" years old");

System.out.println(b.name+"is "+b.age+" years old");

}

}

程序执行结果：

Dog is 3 years old

cat is 5 years old

由此可以知道，类Animal的无参构造函数为name属性赋值为“Dog”，为age属性赋值为“3”。因此，可以写出类Animal的代码如下：

class Animal {

String name;

int age;

Animal(){

name="Dog";

age=3;

}

Animal(Stringname,int age){

this.name=name;

this.age=age;

}

}

实际上这就是上一篇文章中的例子，那么封装在这里的含义如下：

l 类本身就实现了封装功能，此处类Animal定义了两个属性，两个构造函数，其只属于Animal类。

l 通过访问修饰符来限制对类的属性和方法的访问，各修饰符含义如下：

Private:成员变量和方法只能在类内被访问，具有类可见性

默认： 成员变量和方法只能被同一个包里的类访问，具有包可见性。

Protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问

Public：可以被同一个项目中所有的类访问，具有项目可见性，这是最大的访问权限

l 只能通过类本身定义的方法来对该类所实例化的对象进行数据的访问和处理。比如想对实例化的对象添加其它的一个方法和属性是不可能的。这就体现的类的封装性。这里也可以理解一下为什么类被称之为模板或者蓝图。

二、继承

1、继承是面向对象的三大特征之一，也是实现代码复用的重要手段。Java的继承具有单继承的特点，即只能继承自一个父类，每个子类只有一个直接父类，但是其父类又可以继承于另一个类，从而实现了子类可以间接继承多个父类，但其本质上划分仍然是一个父类和子类的关系。

2、Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类称为父类(有的也称其为基类、超类)，父类和子类的关系，是一种一般和特殊的关系。就像是水果和苹果的关系，苹果继承了水果，苹果是水果的子类，水果是苹果的父类，则苹果是一种特殊的水果。

3、Java使用extends作为继承的关键字，extends关键字在英文是扩展的意思，而不是继承。为什么国内把extends翻译成继承呢？除了与历史原因有关外，把extends翻译成为继承也是有其道理的：子类扩展父类，将可以获得父类的全部属性和方法，这与汉语中得继承（子辈从父辈那里获得一笔财富成为继承）具有很好的类似性。

值得指出的是：Java的子类不能获得父类的构造器。

创建子类一般形式如下：

class 类名 extends 父类名{

子类体

}

4、子类与父类的变量、方法关系

子类可以继承父类的所有特性，但其可见性，由父类成员变量、方法的修饰符决定。对于被private修饰的类成员变量或方法，其子类是不可见的，也即不可访问；对于定义为默认访问（没有修饰符修饰）的类成员变量或方法，只有与父类同处于一个包中的子类可以访问；对于定义为public或protected 的类成员变量或方法，所有子类都可以访问。

子类中可以声明与父类同名的成员变量，这时父类的成员变量就被隐藏起来了，在子类中直接访问到的是子类中定义的成员变量。

子类中也可以声明与父类相同的成员方法，包括返回值类型、方法名、形式参数都应保持一致，称为方法的覆盖。

如果在子类中需要访问父类中定义的同名成员变量或方法，需要用的关键字super。Java中通过super来实现对被隐藏或被覆盖的父类成员的访问。super 的使用有三种情况：

l 访问父类被隐藏的成员变量和成员方法；

super.成员变量名;

l 调用父类中被覆盖的方法，如：

super.成员方法名([参数列]);

l 调用父类的构造函数，如：

super([参数列表]);

super( )只能在子类的构造函数中出现，并且永远都是位于子类构造函数中的第一条语句。

举例：

class BaseClass{

public double weight;

public void info(){

System.out.println("我的体重是"+weight+"千克");

}

}

public class ExtendsDemo001 extends BaseClass{

public static void main(String[]args) {

//创建ExtendsDemo001对象

ExtendsDemo001 ed = new ExtendsDemo001();

//ExtendsDemo001本身没有weight属性，但是ExtendsDemo001的父类有weight属性，也可以访问ExtendsDemo001对象的属性

ed.weight = 56;

//调用ExtendsDemo001对象的info()方法

ed.info();

}

}

举例二：

class Animal {

String name="animal";

int age;

void move(){

System.out.println("animalmove");

}

}

classDog extends Animal{

String name="dog"; //隐藏了父类的name属性;

float weight; //子类新增成员变量

void move(){ //覆盖了父类的方法move()

super.move(); //用super调用父类的方法

System.out.println("Dog Move");

}

}

publicclass InheritDemo{

public static void main(String args[]){

Dog d=new Dog();

d.age=5;

d.weight=6;

System.out.println(d.name+" is"+d.age+" years old");

System.out.println("weight:"+d.weight);

d.move();

}

}

程序运行结果：

dog is5 years old

weight:6.0

animalmove

DogMove

举例三：

classSuperClass {

SuperClass() {

System.out.println("调用父类无参构造函数");

}

SuperClass(int n) {

System.out.println("调用父类有参构造函数：" + n );

}

}

classSubClass extends SuperClass{

SubClass(int n) {

System.out.println("调用子类有参构造函数：" + n );

}

SubClass(){

super(200);

System.out.println("调用子类无参构造函数");

}

}

publicclass InheritDemo2{

public static void main(String arg[]) {

SubClass s1 = new SubClass();

SubClass s2 = new SubClass(100);

}

}

程序运行结果：

调用父类有参构造函数：200

调用子类无参构造函数

调用父类无参构造函数

调用子类有参构造函数：100

请自行分析程序运行的结果，体会继承的用法。

java中的继承是什么

Java继承是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。[1]

Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以分隔符先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。

类和类之间的继承关系可以用UML符号表示，其中父类又叫超类或基类，子类又叫派生类。父类是子类的一般化，子类是父类的特化（具体化)。

JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口，从而克服单继承的缺点。

在面向对象程序设计中运用继承原则，就是在每个由一般类和特殊类形成的一般——特殊结构中，把一般类的对象实例和所有特殊类的对象实例都共同具有的属性和操作一次性地在一般类中进行显式的定义，在特殊类中不再重复地定义一般类中已经定义的东西，但是在语义上，特殊类却自动地、隐含地拥有它的一般类(以及所有更上层的一般类)中定义的属性和操作。特殊类的对象拥有其一般类的全部或部分属性与方法，称作特殊类对一般类的继承。

继承所表达的就是一种对象类之间的相交关系，它使得某类对象可以继承另外一类对象的数据成员和成员方法。若类B继承类A，则属于B的对象便具有类A的全部或部分性质(数据属性)和功能(操作)，我们称被继承的类A为基类、父类或超类，而称继承类B为A的派生类或子类。

继承避免了对一般类和特殊类之间共同特征进行的重复描述。同时，通过继承可以清晰地表达每一项共同特征所适应的概念范围——在一般类中定义的属性和操作适应于这个类本身以及它以下的每一层特殊类的全部对象。运用继承原则使得系统模型比较简练也比较清晰。

什么是Java的封装继承和多态？在线等！！！！

封装、继承、多态

比较抽象，只是一种概念，刚开始学的时候无需太过于深究，如果要你一上来学JAVA就理解这些东西，有点牵强，你所要做的就是至少看到代码知道这个用到的是什么。

封装的概念好比一辆汽车，你学开车的时候只需学会诸如踩油门、刹车，转方向盘即可，无需去了解它的发动机是如何发动。

继承，先说说我对类的理解，类起到的作用有：分类（你所用某个类创建的对象实际上该类的个案）和模板的作用，那么继承则起到了对类再次分类的作用，比如，有个类“动物”，“哺乳动物”继承“动物”，再往下“马”又继承了“哺乳动物”这个类。在这里，我们从下往上讲，首先，我们把某种东西划分出来，叫做“马”（当然还有“牛”，“鱼”等等），接着，我们发现，“马”，“羊”等还有很多共同的特点，于是，我们再次划分出了“哺乳动物”这个类，再次分类，我们则有了“动物”。但在实际开发中，我们一般是从上往下定义的，即先有了“动物”，再有“哺乳动物”，最后有“马”。

多态，正如上面朋友所说一重写，二重载。用汉字来打个比方，比如“开”这个字，在不同的时候各有的意思，比如“开门”，“开窗”，甚至有“开车”，“开饭”等，具有相同名称但操作不同。具体的实现我就不累述了。

说说接口吧，在JAVA不支持多继承的，实际上接口起到了类似多继承的作用，一个类只能继承另一个类（或抽象类）但可以实现多个接口。打个比方，“张三”，他是一个“人”，因此他继承了“人”；与此同时，他是一个“司机”，他的平时行为还有“开车”，很显然，这并不能从“人”这个类里继承下来。怎么办？JAVA里只支持单继承，这个时候，接口就起到了作用，它定义了“司机”这个接口，“张三”实现了它，因此，他会开车了。

类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；

实例变量是类实例化后，系统为其创建的一个类的实例变量的拷贝，即一个实例拥有一个实例变量。

类变量则是用static声明，系统为每个类变量分配一次存储空间。即所有的实例共享一个类变量。

java里面的面向对象编程有关于封装继承通俗讲是什么意思

封装会对类的成员变量加上绝对领域，因此没有人能够恶搞你的变量。

比如一个类：Dog

class Dog {

int height;

}

当然我们可以指定这只狗的高度： new Dog().height = 34;

但是绝对不应该：new Dog().height = 0; 因为狗的高度能是0么？刚出生也不能是0啊！但是这个错误是有可能发生的，因为这个成员变量height可以任意的被修改和访问。

所以，封装的基本原则：

将你的成员变量标记为私有的，并提供公有的get和set方法来控制存取动作。

class Dog {

private int height;

public int getHeight() {

return this.height;

}

public void setHeight(int h) {

if(h 5) { // 此检查可以确保高度不会低于5

this.height = h;

}

}

}

这回明白了吧？但是有的时候你会发现，好多情况，我们确实把属性设置为私有的，而且也提供set和get方法，但是方法内部什么都没做，只是简单的赋值或者返回属性值，这不是和以前一样也可以任意更改了么？，这里告诉你为什么，这种方式已经形成了一种规范，可能这样做暂时看似没什么用，但是是一个标准规范，应该这样去做，因为此时可能我们不想去做些什么，但是以后呢？以后想做直接在方法内部添加判断即可，这时候其他调用了此方法的地方并不需要改变，维护性比较好。

也就是说，除非你是刻意的想让外界直接可以任意访问，否则，我们要尽可能的将属性设置为private私有的，对于方法也是一样，有些方法就是我这个类自己内部调用，内部有用，那我就设为private的，这个具体得根据实际情况分析设计，好处除了上面所述，还有就是 你对外只提供有效的属性或方法，其他的进行隐藏，那么之后，谁使用你这个类，谁调属性或者方法的时候后都会明确的知道，这些对我都是有用的。

当然访问权限修饰词，private，默认的，protected，public 四种，具体用那一种进行修饰，根据实际情况自己看。

封装的目的是增强安全性和简化编程，增强安全性上面说过了，简化编程也就是说，使用者不必了解具体的实现细节，而只是使用 外部接口（方法名和参数列表）就可以了。

再说继承：

继承是类与类之间的关系，class Cat extends Animal 意思就是说猫从动物继承，那么动物被叫做父类，猫被叫做子类，猫类和动物类，这两个类之间的关系是继承关系。

有了继承关系之后，作用之一 就是代码重用，子类从父类继承，那么父类的所有内容（属性和方法），子类无需再次定义就都拥有了，全部都拥有了，但是有些内容比如说 private的属性，拥有是拥有了，但是不能使用，说白了就是有拥有权，没有使用权。

另外一个作用就是继承以后，可以父类引用指向子类对象，也就是向上转型（upcasting），比如：

Animal a = new Dog();

继承了以后，还可以对父类的方法进行重写（Override）。

最重要的一点就是：继承，重写，向上转型，是多态的3个必要的条件，缺一不可。

面向对象的三个特性：封装、继承、多态，多态从另外一个角度，划分开了接口和实现，使我们程序的可扩展性达到了极致，现在明白了吧？之所以现代编程语言都采用面向对象的思想，原因就是这样的程序，代码的重用性，程序的可扩展性，后期的可维护性，以及其他其他的什么什么性 都是非常好的。

我也就理解这么多，写了一个小时，以上绝非复制粘贴，可能我说的也不全面，毕竟就理解到这，自己再看看书吧。

先谢谢了！java里封装、继承、抽象、多态分别是什么意思？请帮我解释的人性化点！

抽象：就是忽略一个主题中与当前目标无关的那些方面，以便充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中一部分细节。抽象包括两方面:一是过程抽象，二是数据抽象。

继承：继承是一种联结类的层次模型，并且允许和鼓励的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过称为类继承。新类继承了原始的特性，新类称为原始的派生类（子类），而原始类称为基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或添加新的方法使之更适合特殊的需要。

封装：是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

多态性：是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决应用程序函数同名问题

打字打死了 我自己整理的看看吧

java面向对象，封装继承多态的定义

封装：

封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和方法结合为一个独立的整体（类），并尽可能隐藏对象的内部实现细节（属性设置成private，以及对于的get、set方法）。

继承：

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。换句话说：父类有的子类都有，父类没有的子类可以根据需要添加。

多态：

多态性是对象多种表现形式的体现。多态存在的三个必要条件：

继承

重写

父类引用指向子类对象

java封装继承是什么的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java封装和继承、java封装继承是什么的信息别忘了在本站进行查找喔。