Java面向對象（二）

source:http://blog.java1234.com/index.html?typeId=1

Java類的繼承

1，繼承定義以及基本使用

定義：子類能夠繼承父類的屬性和方法；

注意點：Java中只支持單繼承； 私有方法不能繼承；

2，方法重寫

所謂方法的重寫 我們可以在子類中根據實際業務把父類的方法重寫；

3，對象實例過程以及super關鍵字

對象實例化 先實例化調用父類構造方法，再調用子類實例化構造方法；

super關鍵主要是調用父類方法或者屬性；

/*** 動物類* @author user**/
public class Animal {private String name; // 姓名private int age;  // 年齡/*** 無參父類構造方法*/public Animal() {System.out.println("無參父類構造方法");}/*** 有參父類構造方法* @param name 姓名* @param age 年齡*/public Animal(String name,int age) {System.out.println("有參父類構造方法");this.name=name;this.age=age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void say(){System.out.println("我是一個動物，我叫："+this.name+",我的年齡是："+this.age);}
}/*** 定義一個Cat類，繼承自Animal* @author user**/
public class Cat extends Animal{private String address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}public Cat() {super();System.out.println("子類無參構造方法");}public Cat(String name, int age,String address) {super(name, age);this.address=address;System.out.println("子類有參構造方法");}/*** 重寫父類的say方法*/public void say(){super.say(); // 調用父類的say()方法System.out.println("我是一個貓，我叫："+this.getName()+",我的年齡是："+this.getAge()+"，我來自："+this.getAddress());}public static void main(String[] args) {Cat cat=new Cat("Mini",2,"火星");/*cat.setName("Mini");cat.setAge(2);*/cat.say();}
}

運行輸出：

有參父類構造方法

子類有參構造方法

我是一個動物，我叫：Mini,我的年齡是：2

我是一個貓，我叫：Mini,我的年齡是：2，我來自：火星

final關鍵字

final是終結 完結的意思；

使用final聲明的類不能被繼承；

使用final聲明的方法不能被子類覆蓋；

使用final聲明的變量不能被修改，即為常量；

抽象類

定義：在java中，含有抽象方法的類稱為抽象類，同樣不能生成對象；

注意點：

1，包含一個抽象方法的類是抽象類；

2，抽象類和抽象方法都要用abstract關鍵字修飾；

3，抽象方法只需要聲明而不需要實現；

4，抽象類必須被子類（假如不是抽象類）必須重寫抽象中的全部抽象方法；

5，抽象類不能被實例化；

/*** 定義一個抽象類People* @author user**/
public abstract class People {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}public void say(){System.out.println("我的姓名是："+this.getName());}/*** 定義一個抽象方法 職業 讓子類去具體實現*/public abstract void profession();}public class Student extends People{@Overridepublic void profession() {System.out.println("職業是：學生");}}public class Teacher extends People{@Overridepublic void profession() {System.out.println("職業是：老師");}
}public class Test {public static void main(String[] args) {Student student=new Student();student.profession();Teacher teacher=new Teacher();teacher.profession();}
}

運行輸出：

職業是：學生

職業是：老師

接口

接口定義：一種特殊的“抽象類”，沒有普通方法，由全局常量和公共的抽象方法所組成；

1，接口的定義

接口定義用關鍵字 interface，注意點：由于接口里的方法都是抽象的，所以abstract可以省略，實際開發一般都是省略的，開發者的習慣；

2，實現接口 可以實現一個或者多個接口，實現接口我們用implements關鍵字；

3，繼承類和實現接口 先繼承，后實現接口；

4，接口的繼承 ?接口可以多繼承；

對象的多態性

多態性表現：

1，方法的重載和重寫；

2，可以用父類的引用指向子類的具體實現，而且可以隨時更換為其他子類的具體實現；

public class Animal {public void say(){System.out.println("我是一個動物");}
}
public class Cat extends Animal{public void say(){System.out.println("我是一個貓");}
}
public class Dog extends Animal{public void say(){System.out.println("我是一個狗");}
}
public class Test {public static void main(String[] args) {Dog dog=new Dog();dog.say();Cat cat=new Cat();cat.say();}
}

運行輸出：

我是一個狗

我是一個貓

//多態測試，父類引用指向子類具體實現
public class Test {public static void main(String[] args) {// 父類引用指向Dog子類的具體實現Animal animal=new Dog();animal.say();// 更換實現animal=new Cat();animal.say();}
}

運行輸出：

我是一個狗

我是一個貓

?

對象的轉型：

向上轉型：子類對象->父類對象 安全

向下轉型：父類對象->子類對象 不安全

Object類

Object類是所有類的父類；

Object類的常用方法

1，public String toString() 返回該對象的字符串表示；

2，public boolean equals(Object obj) 指示其他某個對象是否與此對象“相等”；

instanceof關鍵字

作用：判斷一個對象是否屬于一個類

格式：對象 instanceof 類 返回布爾類型

public class Animal {public void say(){System.out.println("我是一個動物");}
}
public class Dog extends Animal{public void say(){System.out.println("我是一只狗");}
}
public class Cat extends Animal{public void say(){System.out.println("我是一只貓");}
}
public class Test {public static void main(String[] args) {Animal dog=new Dog();System.out.println("dog對象是否屬于Animal類："+(dog instanceof Animal));System.out.println("dog對象是否屬于Dog類："+(dog instanceof Dog));System.out.println("dog對象是否屬于Cat類："+(dog instanceof Cat));}
}

運行輸出：

dog對象是否屬于Animal類：true

dog對象是否屬于Dog類：true

dog對象是否屬于Cat類：false

匿名內部類

類的內部再定義類；

匿名內部類 這里指的是實例化內部對象 就是沒有名字的內部類；

?

作用：假如某個類只使用一次，則可以使用匿名內部類；

包裝類

每個基本類型都有一個對應的類；就是所謂的包裝類；

?

1，裝箱和拆箱

基本類型和類類型可以相互轉換；

基本類型到類類型的轉換叫做裝箱；

類類型到基本類型的轉換叫做拆箱；

public static void main(String[] args) {int a=1;Integer i=new Integer(a); // 裝箱int b=i.intValue(); // 拆箱System.out.println("a="+a);System.out.println("i="+i);System.out.println("b="+b);
}

運行輸出：

a=1

i=1

b=1

2，自動裝箱和拆箱

在類類型和基本類型的轉換中，是自動轉換的 無需強制類型轉換；

public static void main(String[] args) {Integer i=1; // 自動裝箱的過程 自動把基本類型轉換成類類型int i2=i; // 自動拆箱的過程 自動把類類型轉成基本類型System.out.println("i="+i);System.out.println("i2="+i2);
}

運行輸出：

i=1

i2=1

3，包裝類的作用

因為包裝類是類類型 所有jdk里提供了很多有用的方法給我們用；

比如從用戶界面來兩個字符串數據a,b 然后我們程序里要進行相加運算。這時候包裝類就派上用場了，我們可以用包裝類的方法類進行類型轉換。

public static void main(String[] args) {String a="3";String b="5";int m=Integer.valueOf(a); // 調用Integer類的valuesOf方法 把字符串類型轉換成int類型int n=Integer.valueOf(b);System.out.println("a+b="+(m+n));
}

運行輸出：

a+b=8

單例模式

在Java應用中，單例對象能保證在一個JVM中，該對象只有一個實例存在；

?

有兩種實現，一種是餓漢式，一種是懶漢式；

public class Singleton {/*** 構造方法私有*/private Singleton(){}/*** 餓漢式單例實現*/private static final Singleton single=new Singleton();/*** 獲取實例*/public static Singleton getInstance(){return single;}
}public class Singleton2 {/*** 構造方法私有*/private Singleton2(){}/*** 懶漢式單例實現 在第一次調用的時候實例化*/private static Singleton2 single;/*** 獲取實例*/public synchronized static Singleton2 getInstance(){if(single==null){System.out.println("第一次調用的實例化");single=new Singleton2();}return single;}
}public class Test {public static void main(String[] args) {Singleton singleton1=Singleton.getInstance();Singleton singleton2=Singleton.getInstance();System.out.println("餓漢式："+(singleton1==singleton2));Singleton2 singleton3=Singleton2.getInstance();Singleton2 singleton4=Singleton2.getInstance();System.out.println("懶漢式："+(singleton3==singleton4));}
}

運行輸出：

餓漢式：true

第一次調用的實例化

懶漢式：true

表示圖形

//實現一個類，用來表示圖形，定義方法，可以分別計算出矩形和圓形的面積和周長
/*** 圖形接口* @author user**/
public interface Graphical {/*** 求面積方法* @return*/public float mianji();/*** 求周長方法* @return*/public float zhouChang();
}/*** 矩形類* @author user**/
public class Rectangle implements Graphical{private float c; // 長度private float k; // 寬度public Rectangle(float c, float k) {super();this.c = c;this.k = k;}@Overridepublic float mianji() {return c*k;}@Overridepublic float zhouChang() {return 2*(c+k);}}/*** 圓形* @author user**/
public class Circular implements Graphical{private float r; // 半徑public Circular(float r) {super();this.r = r;}@Overridepublic float mianji() {return (float) (Math.PI*r*r);}@Overridepublic float zhouChang() {return (float) (2*Math.PI*r);}}public class Test {public static void main(String[] args) {Rectangle r=new Rectangle(2,3.5f);System.out.println("矩形的面積："+r.mianji());System.out.println("矩形的周長："+r.zhouChang());Circular c=new Circular(1.5f);System.out.println("圓形的面積："+c.mianji());System.out.println("圓形的周長："+c.zhouChang());}
}

運行輸出:

矩形的面積：7.0

矩形的周長：11.0

圓形的面積：7.0685835

圓形的周長：9.424778

public?void?f1(){

????????System.out.println("汪汪...");

????}