[code="java"]public class Point {
int x , y ;
void output(){
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args){
Point pt;
pt = new Point();
pt.x = 10 ;
pt.y = 20 ;
pt.output();
}
}[/code]
需求 ： 編寫一個駕駛汽車的方法 。
面向過程： 編寫一個方法 drivecar() ;
面向對象： 將CAR看作一個對象 ，將CAR的共性抽取出來 ，設計一個CAR類，類中定義一個方法drive();,調用CAR.drive() ，實現需求 。
* 類的構造方法 ：
[code="java"]public class Point {
int x , y ;
Point(int a ,int b){ //構造方法 ：構造方法的名稱和類名是一樣的 ，沒有返回值。
x=a;
y=b;
}
void output(){
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args){
Point pt;
pt = new Point(3,5);//在這里傳參
//pt.x = 10 ;
//pt.y = 20 ;
pt.output();
}
}[/code]
1，構造方法的名字和類名一樣，并且沒有返回值。
2，構造方法只要用于類的對象定義初始化狀態。
3，不能直接調用構造方法 ，必須new關鍵字，創建類的實例。
4，java類都要求有構造方法 ，如果沒有定義構造方法，java編譯器會自動為我們添加一個缺省的構造方法。
5，javap.exe---->反編譯工具
new 關鍵字的理解
1，為對象分配內存空間。
2，引起對象構造方法的調用。
3，為對象返回一個引用 。
各種數據類型的默認值 ：
1，數值型 0
2，boolean false
3，char '\0'
4,對象 null
方法的重載 overload ：
條件 ：方法的名稱相同，但參數類型或者參數個數不同，才能構成方法的重載。
[code="java"]
public class Point {
int x , y ;
Point(int a ,int b){ //構造方法 ：構造方法的名稱和類名是一樣的 ，沒有返回值。
x=a;
y=b;
}
Point(){
}
void output(){
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args){
Point pt;
pt = new Point(3,5);//這樣會調用帶有參數的構造方法
pt = new Point();//這樣會調用缺省無參的構造方法
//pt.x = 10 ;
//pt.y = 20 ;
pt.output();
}
}[/code]
特殊變量 this ：
1，this變量代表對象本身。
2，當類中有兩個同名變量，一個屬于類的成員變量 ，一個屬于方法里面的局部變量 ，使用this區分成員變量和局部變量。
3，使用this簡化構造函數的調用。
實例方法和實例數據成員的說明 ：
1，一個類所有的實例對象調用的成員方法在內存中只有一份拷貝，盡管在內存中有可能有多個對象，
而數據成員在類的每個對象所在的內存中都存在一份拷貝。
2.this對象允許相同的實例方法為不同的對象工作。
當調用static靜態方法時，可以直接調用類名.方法 ：
[code="java"]public class Point {
int x , y ;
Point(int a ,int b){ x=a;
y=b;
}
static void output(){
System.out.println("靜態方法");
}
public static void main(String[] args){
// Point pt;
// pt = new Point(3,5);//在這里傳參
// pt.x = 10 ;
// pt.y = 20 ;
// pt.output();
Point.output(); //直接調用
}
}[/code]
關鍵字 static ：
1，靜態方法只屬于類的本身 ，稱為類的方法 ，非靜態方法可稱為實例方法。
2，靜態方法和靜態變量是屬于同一個類，而不屬于類的對象。
3，靜態方法和靜態變量可以直接通過類名引用 。
4，在靜態方法中不能訪問非靜態非靜態方法和引用非靜態成員，反之可以。
5，可以用類的對象obj去調用靜態的方法method()，如obj.method().
常量的定義 ：
1，例如 ： static final double PI = 3.1415926 ；
2，作為一種約定 ，在定義常量時 ，一般采用大寫形式 。
3，final常量可以在聲明的同時賦予初值 ，也可以在構造函數中賦予初值。
4，為了節省內存 ，我們通常將常量聲明為static 。
類的繼承 ：
被繼承的類稱為超類（父類、基類） ，繼承的類稱為子類（派生類） 。java中不允許多繼承。
方法的覆蓋 ： override
在子類中定義一個與父類同名，返回類型，參數類型均相同的一個方法 ，稱為方法的覆蓋 。覆蓋發生在子類與父類之間 。
特殊變量super ：
1，特殊變量super提供了對父類的訪問。
2，可以使用super訪問父類被子類隱藏的變量或覆蓋的方法 。
3，每個子類構造方法的第一條語句，都是隱含的調用super（），如果父類沒有這種形式的構造方法 ，那么在編譯的時候就會據報錯 。
[code="java"]
class Animal{
int height , weight ;
void eat(){
System.out.println("animal eat");
}
void sleep(){
System.out.println("animal sleep");
}
void breathe(){
System.out.println("animal breathe");
}
}
class Fish extends Animal{
void breathe(){
super.breathe();//子類調用父類的方法 。
System.out.println("fish breathe");
}
}
class Integration{
public static void main(String[]aargs){
Animal an = new Animal();
Fish fh = new Fish();
an.breathe();
fh.height= 22;
fh.breathe();
}
}
[/code]
多態性 ：
通過覆蓋父類的方法來實現 ，在運行時根據傳遞對象的引用 ，來調用相應的方法 。
例 ：
需求 ： 求長方形的周長和面積
1，面向過程的方法
[code="java"]class Rectangle{
static int perimeter(int length ,int width)
{
return 2*(length+width);
}
static int area(int length,int width)
{
return length*width ;
}
public static void main(String[] args)
{
System.out.println(Rectangle.perimeter(2, 3));
System.out.println(Rectangle.area(3,5));
}
}[/code]
2，面向對象的方法
[code="java"]class Rectangle
{
int l ,w ;
int perimeter()
{
return 2*(l+w) ;
}
int area()
{
return l*w ;
}
public static void main(String[] args)
{
Rectangle rect1 = new Rectangle();
Rectangle rect2 = new Rectangle();
rect1.l = 10 ;
rect1.w = 91;
rect2.l = 2 ;
rect2.w = 3 ;
System.out.println(rect1.perimeter());
System.out.println(rect1.area());
System.out.println(rect2.perimeter());
System.out.println(rect2.area());
}
}[/code]
方法的使用控制 ：
public protected default private
同類 1 1 1 1
同包 1 1 1
子類 1 1
通用性 1
final 方法 ：
1，為了確保某個函數行為在繼承過程中保持不變，并且不能被覆蓋，可以使用final方法。
2，為了效率上的考慮，將方法聲明為final ，讓編譯器對此方法的調用進行優化，更注意的是 ： 編譯器會自行對final方法進行判斷，并決定是否進行優化，通常在方法的體積很小，而我們確實不希望覆蓋它時，才將他聲明為final 。
3，class中的private和static方法自然就是final 。
抽象方法和抽象類：
1，在類中沒有方法的方法就是抽象方法 。
2，還有抽象方法的類 ，即為抽象類 。
3，如果一個子類沒有實現基類方法中所有抽象方法 ，則子類也為一個抽象類 。
4，我們可以將一個沒有任何抽象方法的類聲明為abstract ，避免這個類產生任何的對象 。
5，抽象類不能實例化對象 。