主方法如何訪問抽象方法的屬性

『壹』 java中，抽象類的不帶返回值的方法子類該如何直接去調用和訪問！

你好，這個分下面幾種情況。
1.如果這個方法是一個抽象方法，那麼子類需要覆寫該方法，然後通過子類對象去調用。
2.如果這個方法是一個private方法，那麼子類將訪問不到這個方法。
3,如果這個方法是一個普通方法，那麼你可以在子類中直接調用。
第三個種類型舉個例子：
public abstract class A {
public void add(){ //....}
}

public class B extends A{}

public class Test{
public static void main(String[] args){
B b = new B() ;
b.add() ;
A a = new B() ;
a.add() ;
}
}

『貳』 C#中有沒有抽象屬性 如果有抽象屬性.具體用在什麼地方.請詳細說明一下.謝謝！

抽象屬性必須要在抽象類聲唯輪明。示例：該文件聲明的 Shape 類包含 double 類型的 Area 屬性。C#// compile with: csc /target:library abstractshape.cspublic abstract class Shape{ private string m_id; public Shape(string s) { // calling the set accessor of the Id property. Id = s; } public string Id { get { return m_id; } set { m_id = value; } } // Area is a read-only property - only a get accessor is needed: public abstract double Area { get; } public override string ToString() { return Id + " Area = " + string.Format("{0:F2}", Area); }}屬性的修飾符就放置在屬性聲明中。例如：public abstract double Area聲明抽象屬性時（如本示例中的 Area），指明哪些屬性訪問器可用即可，不要實現它們。在此示例中，只有一個 get 訪問器可用，因此該屬性是只讀的。下面的代碼演示 Shape 的三個子類，並演示它們如何重寫 Area 屬性來提供自己悔山尺的實現碧高。C#// compile with: csc /target:library /reference:abstractshape.dll shapes.cspublic class Square : Shape{ private int m_side; public Square(int side, string id) : base(id) { m_side = side; } public override double Area { get { // Given the side, return the area of a square: return m_side * m_side; } }}public class Circle : Shape{ private int m_radius; public Circle(int radius, string id) : base(id) { m_radius = radius; } public override double Area { get { // Given the radius, return the area of a circle: return m_radius * m_radius * System.Math.PI; } }}public class Rectangle : Shape{ private int m_width; private int m_height; public Rectangle(int width, int height, string id) : base(id) { m_width = width; m_height = height; } public override double Area { get { // Given the width and height, return the area of a rectangle: return m_width * m_height; } }}下面的代碼演示一個測試程序，它創建若干 Shape 派生對象，並輸出它們的面積。C#// compile with: csc /reference:abstractshape.dll;shapes.dll shapetest.csclass TestClass{ static void Main() { Shape[] shapes = { new Square(5, "Square #1"), new Circle(3, "Circle #1"), new Rectangle( 4, 5, "Rectangle #1") }; System.Console.WriteLine("Shapes Collection"); foreach (Shape s in shapes) { System.Console.WriteLine(s); } }}輸出Shapes CollectionSquare #1 Area = 25.00Circle #1 Area = 28.27Rectangle #1 Area = 20.00

『叄』 java中介面和抽象類以及它們的屬性方法都分別可以用什麼訪問修飾符

【Java介面修飾符是public abstract】

介面就是提供一種統一的」協議」，而介面中的屬性也屬於「協議」中的成員。它們是公共的，靜態的，最終的常量。相當於全局常量。抽象類是不「完全」的類，相當於是介面和具體類的一個中間層。即滿足介面的抽象，也滿足具體的實現。

介面中不可以定義變數即定義的變數前都要加上final修飾，使之成為常量(沒有final修飾的是變數，加上final修飾就會變成常量)。所以介面的屬性默認是public static final 常量，且必須賦初值。

【抽象類】

abstract抽象

1、修飾類時為抽象類，即為概念類，不能實例化；

2、修飾的方法為抽象方法，該方法沒有方法體，必須由子類實現，若沒有實現會報錯；

3、子類若為抽象類，則其中的抽象方法可不實現；

註：抽象類可以沒有抽象方法，但抽象方法所在的類必須為抽象類

『肆』 java中abstract怎麼使用啊，說的詳細點。舉幾個有代表的例子

使用abstract（抽象）修飾符，可以修飾類和方法。

1、abstract修飾類，會使這個類成為一個抽象類，這個類將不能生成對象實例，但可以做為對象變數聲明的類型，也就是編譯時類型，抽象類就像當於一類的半成品，需要子類繼承並覆蓋其中的抽象方法。

2、abstract修飾方法，會使這個方法變成抽象方法，也就是只有聲明（定義）而沒有實現，實現部分以"；"代替。需要子類繼承實現（覆蓋）。

注意：有抽象方法的類一定是抽象類。但是抽象類中不一定都是抽象方法，也可以全是具體方法。

abstract修飾符在修飾類時必須放在類名前。

abstract修飾方法就是要求其子類覆蓋（實現）這個方法。調用時可以以多態方式調用子類覆蓋（實現）後的方法，也就是說抽象方法必須在其子類中實現，除非子類本身也是抽象類。

注意：父類是抽象類，其中有抽象方法，那麼子類繼承父類，並把父類中的所有抽象方法都實現（覆蓋）了，子類才有創建對象的實例的能力，否則子類也必須是抽象類。抽象類中可以有構造方法，是子類在構造子類對象時需要調用的父類（抽象類）的構造方法。

舉個簡單的例子下面有一個抽象類：

abstract class E{

public abstract void show();//public abstract 可以省略

}

然後其它類如果繼承它通常為了實現它裡面的方法：

class F extends E{

void show(){

//寫具體實現的代碼

}

}

最後再主方法裡面定義一個父類引用指向子類對象,就會發生多態現象，比如 ：

E e=new F();

e.show();

實際調用了子類裡面的show()方法 。

(4)主方法如何訪問抽象方法的屬性擴展閱讀：

Java中的abstract方法和abstract類的問題：

當知道一個類的子類將不同的實現某個方法時，把該肢宏類聲明為抽象類很有用，可以共用相同的父類方法，不必再定義。

抽困攔象類和抽象方法的關系：含有抽象方法的類一定是抽象類，抽象類里不一定含有抽象方法。

抽象類存在的意義是用來被繼承的。一個類繼承了一個抽象類，必須實現抽象類裡面所有的抽象方法，否則，此類也是抽象類。

1：用abstract修飾的類表示抽象類，抽象類位於繼承樹的抽象層，抽象類不能被實例化。

2：用abstract修飾的方法表示抽象方法,抽象方法沒有方法體。抽象方法用來歷尺冊描述系統具有什麼功能，但不提供具體的實現。

abstract的規則：

1：抽象類可以沒有抽象方法，但是有抽象方法的類必須定義為抽象類，如果一個子類繼承一個抽象類，子類沒有實現父類的所有抽象方法，那麼子類也要定義為抽象類，否則的話編譯會出錯的。

2：抽象類沒有構造方法，也沒有抽象靜態方法。但是可以有非抽象的構造方法。

3：抽象類不能被實例化，但是可以創建一個引用變數，類型是一個抽象類，並讓它引用非抽象類的子類的一個實例。

4：不能用final 修飾符修飾。

『伍』 抽象類的訪問聲明

abstract類中的方法不可以是private,因為它要被子類重寫啊,你弄成private怎麼重寫呢?

『陸』 java如何拿到一個抽象類的屬性值

直接正常用就可以，但是不能實例化，被繼承後必須overrid所有抽象方法

『柒』 qml中怎麼訪問動態對象的屬性

摘要
一, 接顫悄口基礎知識

1, java語言不支持一個類有多個直接的父類(多繼承),但可以實現（implements）多個介面,間接的實現了多繼承.
2, 與介面相關的設計模式:
1, 定製服務模式
設計精粒度的介面,每個介面代表相關的一組服務,通過繼承來創建復合介面
2, 適配器模式
當每個系統之間介面不匹配時,用適配器來轉換介面
3, 默認適配器模式
為介面提供簡單的默認實現
4, 代理模式
為介面的實現類創建代理類,使用者通過代理來獲得實現類的服務
5, 標識類型模式
用介面來標識一種沒有任何行為的抽象類型
6, 常量介面模式
在介面中定義靜態常量,在其它類中通過import static語句引入這些常量
3, 介面的特徵歸納：
1, 介面中的成員變數默認都是public,static,final類型茄櫻渣的(都可省略),必須被顯示初始化,即介面中的成員變數為常量(大寫,單詞之間用"_"分隔)
2, 介面中的方法默認都是public,abstract類型的(都可省略),沒有方法體,不能被實例化
public interface A
{
int CONST = 1; //合法,CONST默認為public,static,final類型
void method(); //合法,method()默認為public,abstract類型
public abstract void method2(); //method2()顯示聲明為public,abstract類型
}
3, 介面中只能包含public,static,final類型的成員變數和public,abstract類型的成員方法
public interface A
{
int var; //錯,var是常量,必須顯示初始化
void method(){...}; //錯,介面中只能包含抽象方法
protected void method2(); //錯,介面中的方法必須是public類型
static void method3(){...}; //錯,介面中不能包含靜態方法
}
4, 介面中沒有構造方法,不能被實例化
public interface A
{
public A(){...}; //錯,介面中不能包含構造方法
void method();
}
5, 一個介面不能實現(implements)另一個介面,但它可以繼承多個其它的介面
public interface A
{
void methodA();
}
public interface B
{
void methodB();
}
public interface C extends A, B //C稱為復合介面
{
void methodC();
}
public interface C implements A{...} //錯
6, 介面必須通過類來實現它的抽象方法
public class A implements B{...}
7, 當類實現了某個介面時,它必須實現介面中的所有抽象方法,否則這個類必須聲明為抽象的
8, 不允許創建介面的實例(實例化),但允許定義介面類型的引用變數,該引用變數引用實現了這個介面的類的實例
public class B implements A{}
A a = new B(); //引用變數a被定義為A介面類型,引用了B實例
A a = new A(); //錯誤,介面不允許實例化
9, 一個類只能繼承一個直接的父類,但可以實現多個介面,間接的實現了多繼承.
public class A extends B implements C, D{...} //B為class,C,D為interface
4, 通過介面,可以方便地對已經存在的系統進行自下而上的抽象,對於任意兩個類,不管它們是否屬於同一個父類,只有它
們存在相同的功能,就能從中抽象出一個介面類型.對於已經存在的繼承樹,可以方頌老便的從類中抽象出新的介面,但從類
中抽象出新的抽象類卻不那麼容易,因此介面更有利於軟體系統的維護與重構.對於兩個系統,通過介面交互比通過抽象
類交互能獲得更好的松耦合.
5, 介面是構建松耦合軟體系統的重要法寶,由於介面用於描述系統對外提供的所有服務,因此介面中的成員變數和方法都
必須是public類型的,確保外部使用者能訪問它們,介面僅僅描述系統能做什麼,但不指明如何去做,所有介面中的方法
都是抽象方法,介面不涉及和任何具體實例相關的細節,因此介面沒有構造方法,不能被實例化,沒有實例變數.二, 比較抽象類與介面
1, 抽象類與介面都位於繼承樹的上層
相同點
1, 代表系統的抽象層,當一個系統使用一顆繼承樹上的類時,應該盡量把引用變數聲明為繼承樹的上層抽象類型,
這樣可以提高兩個系統之間的送耦合
2, 都不能被實例化
3, 都包含抽象方法,這些抽象方法用於描述系統能提供哪些服務,但不提供具體的實現
不同點:
1, 在抽象類中可以為部分方法提供默認的實現,從而避免在子類中重復實現它們,這是抽象類的優勢,但這一優勢
限制了多繼承,而介面中只能包含抽象方法.
由於在抽象類中允許加入具體方法,因此擴展抽象類的功能,即向抽象類中添加具體方法,不會對它的子類造
成影響,而對於介面,一旦介面被公布,就必須非常穩定,因為隨意在介面中添加抽象方法,會影響到所有的實
現類,這些實現類要麼實現新增的抽象方法,要麼聲明為抽象類
2, 一個類只能繼承一個直接的父類,這個父類可能是抽象類,但一個類可以實現多個介面,這是介面的優勢,但這
一優勢是以不允許為任何方法提供實現作為代價的三, 為什麼Java語言不允許多重繼承呢
當子類覆蓋父類的實例方法或隱藏父類的成員變數及靜態方法時,Java虛擬機採用不同的綁定規則,假如還允許
一個類有多個直接的父類,那麼會使綁定規則更加復雜,因此,為了簡化系統結構設計和動態綁定機制,Java語言
禁止多重繼承.
而介面中只有抽象方法,沒有實例變數和靜態方法,只有介面的實現類才會實現介面的抽象方法(介面中的抽象方
法是通過類來實現的),因此,一個類即使有多個介面,也不會增加Java虛擬機進行動態綁定的復雜度.因為Java虛
擬機永遠不會把方法與介面綁定,而只會把方法與它的實現類綁定.四, 使用介面和抽象類的總體原則:
1, 用介面作為系統與外界交互的窗口
站在外界使用者(另一個系統)的角度,介面向使用者承諾系統能提供哪些服務,站在系統本身的角度,介面制定
系統必須實現哪些服務,介面是系統中最高層次的抽象類型.通過介面交互可以提高兩個系統之間的送耦合
系統A通過系統B進行交互,是指系統A訪問系統B時,
把引用變數聲明為系統B中的介面類型,該引用變數引用系統B中介面的實現類的實例.
public interface B
{
}
public class C implements B
{
}
public class A
{
}
B a = new C();
2, 介面本身必須非常穩定,介面一旦制定,就不允許隨遇更加,否則對外面使用者及系統本身造成影響
3, 用抽象類來定製系統中的擴展點
抽象類來完成部分實現,還要一些功能通過它的子類來實現 2008/1/9
一, Java多態機制中的綁定規則深入剖析
class Base
{
String var = "BaseVar"; //實例變數
static String staticVar = "StaticBaseVar"; //靜態變數 void method() //實例方法
{
System.out.println("Base method");
} static void staticMethod() //靜態方法
{
System.out.println("Static Base method");
}
}public class Sub extends Base
{
String var = "SubVar"; //實例變數
static String staticVar = "StaticSubVar"; //靜態變數

void method() //隱藏父類的method()方法
{
System.out.println("Sub method");
} static void staticMethod() //隱藏父類的staticMethod()方法
{
System.out.println("Static Sub method");
} String subVar = "Var only belonging to Sub"; void subMethod()
{
System.out.println("method only belonging to Sub");
} public static void main(String args[])
{
//引用變數who被聲明為Base類型,引用Sub類的實例
Base who = new Sub();

//成員變數(靜態變數,實例變數)與引用變數所聲明的類型(Base類型)的成員變數綁定
System.out.println("who.var = "+who.var); //所以,列印Base類的var變數
System.out.println("who.staticVar = "+who.staticVar); //所以,列印Base類的staticVar變數 //實例方法與引用變數實際引用的對象(Sub對象)的方法綁定
who.method(); //所以,列印Sub實例的method()方法 //靜態方法與引用變數所聲明的類型(Base類型)的方法綁定
who.staticMethod(); //所以,列印Base類的staticMethod()方法
}
}

【分析過程】
1, 對於一個引用類型的變數,Java編譯器按照它聲明的類型來處理.
例如在以下代碼中,編譯器認為who是Base類型的引用變數,不存在subVar成員變數喝subMethod()方法,編譯報錯
Base who = new Sub(); //引用變數who被聲明為Base類型,引用Sub類的實例
who.subVar = "123"; //編譯錯,在Base類中沒有subVar屬性
who.subMethod(); //編譯錯,在Base類中沒有submethod()方法
如果要訪問Sub類的成員,必須通過強制類型轉換:
Base who = new Sub();
//把Base引用類型的who成員變數強制轉換為Sub引用類型
//把引用變數轉換為子類的類型稱為向下轉型,把引用變數轉換為父類的類型稱為向上轉型
((Sub)who).subVar = "123";
((Sub)who).subMethod();
Java編譯器允許在具有直接或間接繼承關系的類之間進行類型轉換,對於向上轉型,Java編譯器會自動進行,對於
向下轉型,需要進行強制類型轉換
如果兩種類型之間沒有繼續關系,即不在繼承樹的同一個繼承分支上,那麼Java編譯器不允許進行類型轉換
2, 對於一個引用類型的變數,運行時Java虛擬機按照它實際引用的對象來處理
例如以下代碼雖編譯可通過,但運行時會拋出ClassCastException運行時異常
Base who = new Base(); //who引用Base類的實例
Sub s = (Sub)who; //運行時會拋出ClassCastException
在運行時,子類的對象可以轉換為父類類型,而父類的對象實際上無法轉換為子類類型
3, 在運行時環境中,通過引用類型變數來訪問所引用對象的方法和屬性時,Java虛擬機採用以下綁定規則:
1, 實例方法與引用變數實際引用的對象的方法綁定,這種綁定屬於動態綁定,因為是在運行時由Java虛擬機
動態決定的
2, 靜態方法與引用變數所聲明的類型的方法綁定,這種綁定屬於靜態綁定,因為實際上是在編譯階段就已經
綁定
3, 成員變數(靜態變數,實例變數)與引用變數所聲明的類型的成員變數綁定,這種綁定屬於靜態綁定,因為
實際上是在編譯階段就已經綁定

『捌』 怎樣在java中定義一個抽象屬性

只有抽象類和抽象方法，沒有抽象屬性，因為這是無意義的；建議你把抽象類搞清楚就明白了
abstract String s = " " 這樣是不行嘀,抽象的修飾符只能修飾類和方法

『玖』 java中如何理解抽象屬性(abstract)

抽象類不一定要有抽象方法 有抽象方法的類 一定是抽象類
abstract可以用來要求子類必須實現該方法
稱為子類責任
這也就是抽象的實際意義

『拾』 如果在抽象類中定義私有變數，子類繼承抽象類後，子類中的方法需要訪問抽象類中定義的私有變數怎麼辦

私有的子類是不可以用的。但是如果想訪問父乎做類的私有變數或者改變歲畝衡私有變數，可以在超耐並類中定義兩個方法get() set()