1.類型轉換
public class A1
{
	public static void main(String [] args)
	{
	    int i=1;
	    long lo=1L;
	    lo=i;        //自動轉換
	    i=(int) lo;  //強制轉換（可能數據丟失，不建議使用）
	}
}


2.繼承extends

(1)格式：修飾符 class 子類名 extends 父類

例：public class OldCat {          //創建一個類，它有一個方法
    
        	public void catchMouse() {           
        
        	System.out.println("捉到一只老鼠");
    	}
        }
－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class LittleCat extends OldCat {       //創建一個類，它繼承了OldCat類

}

我們可以做一個測試類，創建一個LittleCat對象，它可以調用父類中的方法，也就是說在父類中的成員或方法，子類可以直接使用.


(2)修飾符在繼承中的使用范圍

但也有例外，下面我通過例子來測試一下有哪些情況下不能使用。

在同個包中：
public class Father {                           //創建一個類
    
    public int money = 10000;              //定義了一個public 的數據成員
    
    protected int friends = 5；              //定義了一個protected 的數據成員
    
    String pet    = "Dog";                     //定義了一個default  的數據成員
    
    private  int shoes = 2;                    //定義了一個private 的數據成員
    

}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class Child  extends Father{          //定義一個類Child，它繼承于Father
	

    public void fun() {
        /**
         * 在同一個包中的子類，可以訪問超類中 public 、protected 、默認 的 數據成員和方法
         * 
         * 不能訪問私有的 數據成員和方法
         */
        int m = money;
        int f = friends;
        String p = pet;
        //int s = shoes;         //這條語句不能使用
                
    }

}


不在同一個包里：

public class OtherChild extends Father{          //定義一個類OtherChild，它繼承于Father
	
    public void fun() {
        /**
         * 不在同一個包中的子類，可以訪問超類中 public protected  數據成員和方法
         * 
         * 不能訪問默認的和 private 數據成員和方法
         * 
         */
 
        int m = money;
        int f = friends;
        //String p = pet;       
        //int s = shoes;
        fun();
    }
}

總結：通過以上的例子，我們發現，子類繼承父類，在同一個包里只有private不能使用，不在同一個包里的，只有            public 、protected可以使用。 

(3)關于抽象類的繼承:
     
    抽象類：是由abstract關鍵字實現的，格式為      修飾符  abstract class 類名.
    注：抽象類中至少有一個抽象方法。抽象類不能創建對象，它的方法只能由子類完成，子類如果不是抽象類,它 至少要有一個方法實現抽象方法，修飾符不能比父類更嚴格，類型、方法名以及有無參數要與父類相同,拋出的異常也不能比父類多。

例：public abstract class Animal {                //定義一個抽象類
    
    	public abstract void eat();              //定義一個抽象方法

    	public void fun() {                        //定義一個方法
    	
      	}
       }
－－－－－－－－－－－－－－－－－－－－－－－－－
public class Monkey extends Animal {

     public void eat() {                  //通過此方法，實現抽象方法
     System.out.println(" 猴子正在吃   吃的是蘋果");

    }

}

(4)方法重寫：當父類和子類有相同的方法，可以串改方法，叫方法重寫。

例：public  class  JiCheng1 {                  //定義一個類，它有四個實例變量，分別有四種類型，有一個方法method()
	
	public int a=1;
	protected int b=2;
	int c=3;
	private int d=4;
	
	public void say()
	{
		System.out.println("aaaaaaaa");
	}
	
	public void method ()
	{
		System.out.println("主類中的方法");
	}

}
－－－－－－－－－－－－－－－－－－－－－－－－－
public class JiCheng2 extends JiCheng1{            //定義一個類JiCheng2，繼承父類JiCheng1
	
	public void fun()                    //在子類中可以跟據需要定義父類中所沒有的方法
	{
		int i=a+b+c;         //將a,b,c的和賦給i
		//int k=d;
		System.out.println(i);
	}

	public void method()           //定義一個方法，與父類中方法的相同，輸出的內容不同
	{
		System.out.println("子類中JiCheng2的方法");
	}
}

－－－－－－－－－－－－－－－－－－－－－－－－－

public class Test {　                             //定義一個測試類

	public static void main(String[] args) {           //程序入口
		
		JiCheng1 cc=new JiCheng2();
		cc.say();

		JiCheng1 aa=new JiCheng1();       //創建一個父類的對象
		aa.method();                               //調用父類中的方法
		
		JiCheng2 bb=new JiCheng2();     //創建一個子類的對象
		bb.method();                               //調用子類中的方法
		
		//以下兩條語句實現的功能是方法重寫
		aa=bb;         //將父類指向子類                                       
		aa.method();   //實際上調用的是子類的方法
	}
}

總結：子類只能有一個父類，父類有多個子類，子類可以定義父類中沒有的，子類可以代替父類，父類可以指向子類，子類可以訪問父類中的。繼承可以使程序更靈活。