java 繼承 多態 虛擬類 接口 異常 線程 內部類
java 權限關鍵字 java
private:私有，是一個權限修飾符。用於修飾成員，私有的內容只在本類中有效。數組
public：公共全部的對象均可以引用。函數
class de
{
int x = 3;
public static void main(String[] args)
{
de d = new de();
System.out.println(d.x);
d.x = 9;
System.out.println(d.x);
show(d);
System.out.println(d.x);
}
public static void show(de d)
{
d.x = 4;
}
}
結果爲 ；工具
3 第一個爲引用爲類中的成員變量；this
9 第二個對成員變量從新賦值spa
4 第三個地址變化，由堆地址變爲棧地址線程
javadoc提取信息的格式 javadoc -private -d doc -author -version myHelloworld.java
/**
創建一個用於操做數組的工具類，其中包含着常見的對數組操做的函數如：最值，排序等 。
@author 張三
@version V1.0
*/
public class ArrayTool
{
/**
獲取整型數組的最大值。
@param arr 接收一個元素爲int類型的數組。
@return 該數組的最大的元素值
*/
public static int getMax(int[] arr)
{
int maxIndex = 0;
for(int x=1; x<arr.length; x++)
{
if(arr[x]>arr[maxIndex])
maxIndex = x;//
}
return arr[maxIndex];
}
}
子類能夠繼承和覆蓋父類
覆蓋注意事項：code
1，子類方法覆蓋父類方法時，子類權限必需要大於等於父類的權限。 對象
2，靜態只能覆蓋靜態，或被靜態覆蓋。排序
抽象類
特色：
1，方法只有聲明沒有實現時，該方法就是抽象方法，須要被abstract修飾。
抽象方法必須定義在抽象類中。該類必須也被abstract修飾。
2，抽象類不能夠被實例化。爲何？由於調用抽象方法沒意義。
3，抽象類必須在其子類覆蓋了全部的抽象方法後，該子類才能夠實例化。不然，這個子類仍是抽象類。
1，抽象類中有構造函數嗎？
有，用於給子類對象進行初始化。
2，抽象類能夠不定義抽象方法嗎？
能夠的。 可是不多見，目的就是不讓該類建立對象。AWT的適配器對象就是這種類。
一般這個類中的方法有方法體，可是卻沒有內容。
abstract class Demo
{
Demo()
{
System.out.println("demoa ");
}
abstract /*抽象*/ void show();
void ha()
{
System.out.println("demoa s");
}
}
class DemoA extends Demo
{
void show() //覆蓋虛擬類show
{
System.out.println("demoa show");
}
}
class AS
{
public static void main(String[] args)
{
DemoA a = new DemoA();
a.show();
a.ha(); //虛擬類中的非虛擬方法能夠直接用
}
}
結果 demoa //虛擬類的構造函數
demoa show
demoa s
3，抽象關鍵字不能夠和那些關鍵字共存?
private不行 static不行 final不行 由於虛擬類須要被子類覆蓋
4，抽象類和通常類的異同點。
相同點：
抽象類和通常類都是用來描述事物的，都在內部定了成員。
不一樣：
1，通常類有足夠的信息描述事物。
抽象類描述事物的信息有可能不足。
2，通常類中不能定義抽象方法，只能定非抽象方法。
抽象類中可定義抽象方法，同時也能夠定義非抽象方法。
3，通常類能夠被實例化。
抽象類不能夠被實例化。
5，抽象類必定是個父類嗎？
是的。由於須要子類覆蓋其方法後才能夠對子類實例化。
接口
當一個抽象類中的方法都是抽象的時候，這時能夠將該抽象類用
另外一種形式定義和表示，就是 接口 interface。
對於接口當中常見的成員：並且這些成員都有固定的修飾符。
1，全局常量: public static final
2，抽象方法。public abstract
由此得出結論，接口中的成員都是公共的權限.
interface Demo
{
public static final int NUM = 4;
public abstract void show1();
public abstract void show2();
}
class DemoImpl implements /*實現*/Demo
{
public void show1()
{}
public void show2()
{
}
}
類與類之間是繼承關係，類與接口直接是實現關係。
接口不能夠實例化。只能由實現了接口的子類並覆蓋了接口中全部的抽象方法後，該子類才能夠實例化。
java中不直接支持多繼承，一個類能夠實現多個接口，接口的出現避免了單繼承的侷限性。
interface A
{
public void show();
}
interface Z
{
public int add(int a,int b);
}
class Test implements A,Z//多實現
{
public int add(int a,int b)
{
return a+b;
}
public void show(){}
}
一個類在繼承另外一個類的同時，還能夠實現多個接口。
class Q
{
public void method()
{}
}
abstract class Test2 extends Q implements A,Z
{
}
接口能夠多繼承
interface CC
{
void show();
}
interface MM
{
void method();
}
interface QQ extends CC,MM//接口與接口之間是繼承關係，並且接口能夠多繼承。
{
void function();
}
class WW implements QQ
{
//覆蓋3個方法。
public void show(){}
public void method(){}
public void function(){}
}
接口與抽象類不一樣點：
1，抽象類須要被繼承，並且只能單繼承。
接口須要被實現，並且能夠多實現。
2，抽象類中能夠定義抽象方法和非抽象方法，子類繼承後，能夠直接使用非抽象方法。
接口中只能定義抽象方法，必須由子類去實現。
多態
class 動物
{}
class 貓 extends 動物
{}
動物 x = new 貓();//一個對象，兩種形態。
貓這類事物即具有者貓的形態，又具有着動物的形態。這就是對象的多態性。
父類或者接口的引用指向其子類的對象。
多態的好處：
提升了代碼的擴展性，前期定義的代碼可使用後期的內容。
多態的弊端：
前期定義的內容不能使用(調用)後期子類的特有內容。
多態的前提：
1，必須有關係，繼承，實現。
2，要有覆蓋。
class Fu
{
int num = 3;
void show()
{
System.out.println("fu show");
}
static void method()
{
System.out.println("fu static method");
}
}
class Zi extends Fu
{
int num = 4;
void show()
{
System.out.println("zi show");
}
static void method()
{
System.out.println("zi static method");
}
}
class DuoTaiDemo3
{
public static void main(String[] args)
{
Fu f = new Zi();
f.method(); //fu static method 靜態函數 看左邊
f.show(); //zi show 成員函數非靜態 看右邊
System.out.println(f.num); //3 成員函數 看左邊
}
}
多態時，成員的特色：
1，成員變量。編譯和運行都參考等號的左邊
2，成員函數(非靜態)。編譯看左邊，運行看右邊
3，靜態函數。編譯和運行都看左邊。
內部類
class Outer
{
int num = 3;
class Inner
{
int num = 4;
void show()
{
int num = 5;
System.out.println(Outer.this.num);
}
}
void method()
{
new Inner().show();
}
}
class InnerClassDemo2
{
public static void main(String[] args)
{
new Outer().method();
new Outer().new Inner().show(); //直接引用內部類
}
}
System.out.println(Outer.this.num); //結果爲 3
//去掉Outer. 結果爲 4
//去掉this. 結果爲5
異常
throws 和throw的區別。
1，throws使用在函數上。
throw使用在函數內。
2，throws拋出的是異常類，能夠拋出多個，用逗號隔開。
throw拋出的是異常對象。
try
{
//須要被檢測異常的代碼。
}
catch(異常類 變量)//該變量用於接收發生的異常對象
{
//處理異常的代碼。
}
finally
{
//必定會被執行的代碼。
}
若是catch中有return，則不會執行到這裏，而finally中的內容會被執行
class Demo
{
public int method(int[] arr,int index) throws NullPointerException
{
if(arr==null)
throw new NullPointerException("沒有任何數組實體");
if(index<0)
throw new FuShuIndexException();
return arr[index];
}
}
class ExceptionDemo4
{
public static void main(String[] args)
{
int[] arr = new int[3];
Demo d = new Demo();
try
{
int num = d.method(null,-1); //調用method方法，可能會產生異常
System.out.println("num="+num);
}
catch(NullPointerException e)
{
System.out.println(e.toString());
}
System.out.println("over");
}
}
package myclass 生成類放 myclass目錄下 import myclass.*; 導入myclass類
正在進行的程序爲進程：應用程序對應的在內存中的空間，進程 不運行，只是分配內存空間
線程是：進程中 執行路徑 決定在內存中走那些內存
建立線程步驟：
1，定義一個類繼承Thread類。
2，覆蓋Thread類中的run方法。
3，直接建立Thread的子類對象建立線程。
4，調用start方法開啓線程並調用線程的任務run方法執行。
class Demo extends Thread
{
public void run()
{
for(int x=0; x<10; x++)
{
for(int y=-9999999; y<999999999; y++){} //加點延時爲了體現線程
System.out.println(name+" x="+x+" name="+Thread.currentThread().getName());
}
}
}
class ThreadDemo2
{
public static void main(String[] args)
{
Demo d1 = new Demo();
Demo d2 = new Demo();
d1.start();//開啓線程，調用run方法。
d2.start();
}
}
1,定義類實現Runnable接口。
2，覆蓋接口中的run方法，將線程的任務代碼封裝到run方法中。
3，經過Thread類建立線程對象，並將Runnable接口的子類對象做爲Thread類的構造函數的參數進行傳遞。
class Demo implements Runnable//extends Fu //準備擴展Demo類的功能，讓其中的內容能夠做爲線程的任務執行。
//經過接口的形式完成。
{
public void run()
{
show();
}
public void show()
{
for(int x=0; x<20; x++)
{
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}
- 1. JAVA繼承、接口、多態
- 2. java接口、繼承、多態
- 3. 多態、內部類、Object、異常
- 4. JAVA學習筆記 接口外部類，內部類，多態
- 5. 【Java基礎】繼承 多態 接口 異常 面試場問題
- 6. Java 接口、繼承與多態
- 7. 接口類的多繼承以及抽象類的單繼承
- 8. 接口、繼承與多態
- 9. java接口和內部類
- 10. 內部類與異常類
- 更多相關文章...
- • C# 多線程 - C#教程
- • C# 繼承 - C#教程
- • Kotlin學習（二）基本類型
- • Java 8 Stream 教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. JAVA繼承、接口、多態
- 2. java接口、繼承、多態
- 3. 多態、內部類、Object、異常
- 4. JAVA學習筆記 接口外部類，內部類，多態
- 5. 【Java基礎】繼承 多態 接口 異常 面試場問題
- 6. Java 接口、繼承與多態
- 7. 接口類的多繼承以及抽象類的單繼承
- 8. 接口、繼承與多態
- 9. java接口和內部類
- 10. 內部類與異常類