編程繼承

① 面向對象編程中的」繼承」的概念是指

是指：派生自同一個基類的不同類的對象具有一些共同特徵
「繼承」是面向對象軟體技術當中的一個概念。如果一個類A繼承自另一個類B，就把這個A稱為"B的子類"，而把B稱為"A的父類"。
繼承可以使得子類具有父類的各種屬性和方法，而不需要再次編寫相同的代碼。在令子類繼承父類的同時，可以重新定義某些屬性，並重寫某些方法，即覆蓋父類的原有屬性和方法，使其獲得與父類不同的功能。另外，為子類追加新的屬性和方法也是常見的做法。
有些編程語言支持多重繼承，即一個子類可以同時有多個父類，比如C++編程語言；而在有些編程語言中，一個子類只能繼承自一個父類，比如java編程語言，這時可以利用介面來實現與多重繼承相似的效果。
在c++語言中，一個派生類可以從一個基類派生，也可以從多個基類派生。從一個基類派生的繼承稱為單繼承；從多個基類派生的繼承稱為多繼承。

② java編程：（二）類的繼承

public class DogTest {

public static void main(String[] args) {
Dog dog = new Dog("Mimi ", "3");
dog.setNickname("Baby");
System.out.println(dog.name + "is" + dog.age + " years old");
System.out.println("It』s nickname is " + dog.getNickname());

Animal animal = new Animal("Tom ", "3");
System.out.println(animal.name + animal.run());
}

}

/**
*
*/
package test;

/**
* @author lilin
*
*/
public class Dog extends Animal {

public Dog(String name, String age) {
super(name, age);
}

private String nickname;

public String getNickname() {
return nickname;
}

public void setNickname(String nickname) {
this.nickname = nickname;
}

public String run() {
System.out.println("run by four feet");
return null;
}

}

/**
*
*/
package test;

/**
* @author lilin
*
*/
public class Animal {

protected String name;

protected String age;

public Animal(String name, String age) {
this.name = name;
this.age = age;
}

public String run() {
return "can run";
}

}

③ 編程中封裝和繼承是啥意思呀

以java語言為例吧。繼承就是子類可以繼承父類的變數或方法，可以實現代碼的復用。

④ 使用java繼承機制編程有什麼好處談談你的實踐體會

更安全。
繼承簡化了人們對事物的認識和描述，能清晰體現相關類間的層次結構關系。繼承提供了軟體復用功能。這種做法能減小代碼和數據的冗餘度，大大增加程序的重用性。提供多重繼承機制。出於安全性和可靠性的考慮，僅支持單重繼承，而通過使用介面機制來實現多重繼承。
Java是一門面向對象編程語言，不僅吸收了C++語言的各種優點，還摒棄了C++里難以理解的多繼承、指針等概念，因此Java語言具有功能強大和簡單易用兩個特徵。Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。

⑤ java編程 繼承關系

/*
* 定義交通工具，汽車，火車，飛機這些類，注意它們的繼承關系，為這些類提供超出3個不同的構造器
*/
class Transport {

public Transport() {
}
}

class Bus extends Transport {

private String busName;

public Bus(String busName) {
this.busName = busName;
}
}

class Train extends Transport {

private String trainName;
private double trainSpeed;

public Train(String trainName, double trainSpeed) {
this.trainName = trainName;
this.trainSpeed = trainSpeed;
}
}

class Airplane extends Transport {

private String airplaneName;
private double airplaneSpeed;
private String Voyage;

public Airplane(String airplaneName, double airplaneSpeed, String Voyage) {
this.airplaneName = airplaneName;
this.airplaneSpeed = airplaneSpeed;
this.Voyage = Voyage;
}
}

⑥ 編程中的單一繼承性是指什麼

在java中是單繼承，C中是多繼承，
單繼承指的就是一個類只能有一個直接父類，

⑦ 編程語言中的，封裝，繼承，多態 怎麼解釋

網上能找到的都是說的嚴謹的，如果沒理解真沒辦法一兩句說清楚，封裝提高了代碼可重用性可維擴性，寫方法、類都是封裝；繼承是然將兩個或兩個以為有共性的成員拿出來寫成基類，其根本目的還是提高可重用性，並且也更符日常生活中的面向對象思想。多態是不同對象實例對同一個消息作出不同響應的能力。但這些不同對象實例必須有共性約束，或是父子類的方法繼承，或是對同一介面的消息實現，比如：員工類有以下子類：項目經理、前台、程序員，都有一個共同成員方法」開工「，當執行該指令時，不同實例所執行的任務是不一樣的

⑧ 編程中繼承的概念

繼承是指一個對象直接使用另一對象的屬性和方法。

繼承可以使得子類具有父類的各種屬性和方法，而不需要再次編寫相同

的代碼。在令子類繼承父類的同時，可以重新定義某些屬性，並重寫某

些方法，即覆蓋父類的原有屬性和方法，使其獲得與父類不同的功能。

同類事物具有共同性，在同類事物中，每個事物又具有其特殊性。運用

抽象的原則舍棄對象的特殊性，抽取其共同性，則得到一個適應於一批

對象的類，這便是基類（父類）,而把具有特殊性的類稱為派生類（子

類），派生類的對象擁有其基類的全部或部分屬性與方法，稱作派生類

對基類的繼承。

⑨ Python面向對象編程之繼承與多態詳解

Python面向對象編程之繼承與多態詳解
本文實例講述了Python面向對象編程之繼承與多態。分享給大家供大家參考，具體如下：
Python 類的繼承
在OOP（Object Oriented Programming）程序設計中，當我們定義一個class的時候，可以從某個現有的class 繼承，新的class稱為子類（Subclass），而被繼承的class稱為基類、父類或超類（Base class、Super class）。
我們先來定義一個class Person，表示人，定義屬性變數 name 及 sex （姓名和性別）；
定義一個方法print_title()：當sex是male時，print man；當sex 是female時，print woman。參考如下代碼：
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
def print_title(self):
if self.sex == "male":
print("man")
elif self.sex == "female":
print("woman")
class Child(Person): # Child 繼承 Person
pass
May = Child("May","female")
Peter = Person("Peter","male")
print(May.name,May.sex,Peter.name,Peter.sex) # 子類繼承父類方法及屬性
May.print_title()
Peter.print_title()

而我們編寫 Child 類，完全可以繼承 Person 類（Child 就是 Person）；使用 class subclass_name(baseclass_name) 來表示繼承；

繼承有什麼好處？最大的好處是子類獲得了父類的全部屬性及功能。如下 Child 類就可以直接使用父類的 print_title() 方法

實例化Child的時候，子類繼承了父類的構造函數，就需要提供父類Person要求的兩個屬性變數 name 及 sex：

在繼承關系中，如果一個實例的數據類型是某個子類，那它也可以被看做是父類（May 既是 Child 又是 Person）。但是，反過來就不行（Peter 僅是 Person，而不是Child）。

繼承還可以一級一級地繼承下來，就好比從爺爺到爸爸、再到兒子這樣的關系。而任何類，最終都可以追溯到根類object，這些繼承關系看上去就像一顆倒著的樹。比如如下的繼承樹：

isinstance() 及 issubclass()

Python 與其他語言不同點在於，當我們定義一個 class 的時候，我們實際上就定義了一種數據類型。我們定義的數據類型和Python自帶的數據類型，比如str、list、dict沒什麼兩樣。

Python 有兩個判斷繼承的函數：isinstance() 用於檢查實例類型；issubclass() 用於檢查類繼承。參見下方示例：

class Person(object):
pass
class Child(Person): # Child 繼承 Person
pass
May = Child()
Peter = Person()
print(isinstance(May,Child)) # True
print(isinstance(May,Person)) # True
print(isinstance(Peter,Child)) # False
print(isinstance(Peter,Person)) # True
print(issubclass(Child,Person)) # True

Python 類的多態

在說明多態是什麼之前，我們在 Child 類中重寫 print_title() 方法：若為male，print boy；若為female，print girl
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
def print_title(self):
if self.sex == "male":
print("man")
elif self.sex == "female":
print("woman")
class Child(Person): # Child 繼承 Person
def print_title(self):
if self.sex == "male":
print("boy")
elif self.sex == "female":
print("girl")
May = Child("May","female")
Peter = Person("Peter","male")
print(May.name,May.sex,Peter.name,Peter.sex)
May.print_title()
Peter.print_title()

當子類和父類都存在相同的 print_title()方法時，子類的 print_title() 覆蓋了父類的 print_title()，在代碼運行時，會調用子類的 print_title()

這樣，我們就獲得了繼承的另一個好處：多態。

多態的好處就是，當我們需要傳入更多的子類，例如新增 Teenagers、Grownups 等時，我們只需要繼承 Person 類型就可以了，而print_title()方法既可以直不重寫（即使用Person的），也可以重寫一個特有的。這就是多態的意思。調用方只管調用，不管細節，而當我們新增一種Person的子類時，只要確保新方法編寫正確，而不用管原來的代碼。這就是著名的「開閉」原則：

對擴展開放（Open for extension）：允許子類重寫方法函數

對修改封閉（Closed for modification）：不重寫，直接繼承父類方法函數

子類重寫構造函數

子類可以沒有構造函數，表示同父類構造一致；子類也可重寫構造函數；現在，我們需要在子類 Child 中新增兩個屬性變數：mother 和 father，我們可以構造如下（建議子類調用父類的構造方法，參見後續代碼）：
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
class Child(Person): # Child 繼承 Person
def __init__(self,name,sex,mother,father):
self.name = name
self.sex = sex
self.mother = mother
self.father = father
May = Child("May","female","April","June")
print(May.name,May.sex,May.mother,May.father)

若父類構造函數包含很多屬性，子類僅需新增1、2個，會有不少冗餘的代碼，這邊，子類可對父類的構造方法進行調用，參考如下：
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
class Child(Person): # Child 繼承 Person
def __init__(self,name,sex,mother,father):
Person.__init__(self,name,sex) # 子類對父類的構造方法的調用
self.mother = mother
self.father = father
May = Child("May","female","April","June")
print(May.name,May.sex,May.mother,May.father)

多重繼承

多重繼承的概念應該比較好理解，比如現在需要新建一個類 baby 繼承 Child ， 可繼承父類及父類上層類的屬性及方法，優先使用層類近的方法，代碼參考如下：
class Person(object):
def __init__(self,name,sex):
self.name = name
self.sex = sex
def print_title(self):
if self.sex == "male":
print("man")
elif self.sex == "female":
print("woman")
class Child(Person):
pass
class Baby(Child):
pass
May = Baby("May","female") # 繼承上上層父類的屬性
print(May.name,May.sex)
May.print_title() # 可使用上上層父類的方法
class Child(Person):
def print_title(self):
if self.sex == "male":
print("boy")
elif self.sex == "female":
print("girl")
class Baby(Child):
pass
May = Baby("May","female")
May.print_title() # 優先使用上層類的方法

⑩ 面向對象編程中的「繼承」的概念是什麼

是指：派生自同一個基類的不同類的對象具有一些共同特徵
「繼承」是面向對象軟體技術當中的一個概念。如果一個類A繼承自另一個類B，就把這個A稱為"B的子類"，而把B稱為"A的父類"。
繼承可以使得子類具有父類的各種屬性和方法，而不需要再次編寫相同的代碼。在令子類繼承父類的同時，可以重新定義某些屬性，並重寫某些方法，即覆蓋父類的原有屬性和方法，使其獲得與父類不同的功能。另外，為子類追加新的屬性和方法也是常見的做法。
有些編程語言支持多重繼承，即一個子類可以同時有多個父類，比如C++編程語言；而在有些編程語言中，一個子類只能繼承自一個父類，比如Java編程語言，這時可以利用介面來實現與多重繼承相似的效果。
在c++語言中，一個派生類可以從一個基類派生，也可以從多個基類派生。從一個基類派生的繼承稱為單繼承；從多個基類派生的繼承稱為多繼承。