JavaSE學習總結（四）——Java面向對象十分鍾入門

本文轉載自查看原文 2017-03-23 13:48 2015 JavaSE/ 第二學期

面向對象編程（Object Oriented Programming，OOP）是一種計算機模擬人類的自然思維方式的編程架構技術，解決了傳統結構化開發方法中客觀世界描述工具與軟件結構的不一致性問題。Java是一種純面向對象的語言，與C語言不一樣他是面向過程的語言。通俗說Java程序主要是由類組成的，而C是由函數組成的。

面向對象非常重要，恰當的使用面向對象會使我們開發的系統擁有“可復用”、“可擴展”、“可維護”的特點。面向對象的概念和應用已超越了程序設計和軟件開發，擴展到如數據庫系統、交互式界面、應用結構、應用平台、分布式系統、網絡管理結構、CAD技術、人工智能等領域。面向對象是一種對現實世界理解和抽象的方法，是計算機編程技術發展到一定階段后的產物，作為開發者面向對象您必須理解后掌握。

面向對象三大特性：封裝、繼承、多態，Java面向對象中的最終父類是：Object（對象）

一、理解類與對象及他們間的關系

面向對象中對象與類是最重要的，先來理解對象、類及他們間的關系。

1.1、對象

世界萬物都是對象（object）,在面向對象中一切都是對象

對象：系統中用來描述客觀事物的實體，構成系統的基本單位
對象封裝了屬性（特征）和方法（操作）

屬性——對象具有的各種特征
每個對象的每個屬性都擁有特定值
例如：布蘭尼和朱麗葉的體重不一樣

方法——對象執行的操作

對象就是封裝了屬性與方法的實體

1.2、類

猜猜下面描述的是什么：
屬性：有排量、有速度、有油耗、有2-5個座位、有4個輪子
方法：載客、加速、轉向、行駛、鳴笛

類：是擁有共同屬性和方法的對象的抽象

1.3、類與對象間的關系

類是抽象的，是概念，是類型，是一類事物的統稱

對象是具體的，是真實的，特指的，是獨一無二的

類是模子，確定對象將會擁有的特征（屬性）和行為（方法）

類是對象的類型

對象是類的實例

類：

package com.zhangguo.c321;

/**冰激凌模具*/
public class Box {
    /**高度*/
    public int h;
    /**寬度*/
    public int w;
    
    /**展示方法*/
    public void show(){
        System.out.println("這個冰激凌模具的高度是："+h+"，寬度"+w);
    }
}

測試：

package com.zhangguo.c321;

public class BoxClient {

    public static void main(String[] args) {
        //創建對象，指定對象類型
        Box m1=new Box();
        //給對象的屬性賦值
        m1.h=70;
        m1.w=30;
        //調用方法
        m1.show();
        
        //new Box()：創建對象，實例化對象，Box m2：指定對象類型，和對象名
        Box m2=new Box();
        //給屬性賦值
        m2.h=15;
        m2.w=40;
        //輸出結果
        m2.show();
        
        int i=1;
       double money=1.5;

    }

}

運行結果：

靜態(static)的屬於類，用類名調用，對象名也可以，只有一份，共享

非靜態的屬於對象，用對象調用，有多份，獨享

package com.zhangguo.c321;

/**冰激凌模具*/
public class Box {
    /**屬性，成員變量 final表示最終的，PI不能被修改，static表示靜態的*/
    public static double PI=3.14;
    /**高度*/
    public int h;
    /**寬度*/
    public int w;
    
    /**展示方法*/
    public void show(){
        System.out.println("這個冰激凌模具的高度是："+h+"，寬度"+w);
    }
}

package com.zhangguo.c321;

/**冰激凌模具*/
public class Box {
    /**屬性，成員變量 final表示最終的，PI不能被修改，static表示靜態的*/
    public static double PI=3.14;
    /**高度*/
    public int h;
    /**寬度*/
    public int w;
    
    /**展示方法*/
    public void show(){
        System.out.println("這個冰激凌模具的高度是："+h+"，寬度"+w);
    }
}

運行結果：

二、了解面向對象編程的意義

面向對象編程（Object Oriented Programming，OOP）是一種計算機模擬人類的自然思維方式的編程架構技術，解決了傳統結構化開發方法中客觀世界描述工具與軟件結構的不一致性問題

面向對象編程是相對面向過程的，如C語言
Java是純面向對象編程語言
面向對象中最重要的是對象與類

三、定義類與實例化對象

3.1、定義類

所有Java程序都以類class為組織單元

關鍵字class定義自定義的數據類型

類將現實世界中的概念模擬到計算機程序中

定義類的基本結構：

public class  類名 {
               //定義屬性部分
               屬性1的類型 屬性1;
               屬性2的類型 屬性2;
                      …
               屬性n的類型 屬性n;

               //定義方法部分
               方法1;
               方法2;
                     …
               方法m;
}

定義一個類的步驟
1、定義類名
2、編寫類的屬性
3、編寫類的方法

定義一個類用來抽象圓形

//1包
package com.gdnf.java.d1;

//注釋
/**
 *圓
 */
//2類
public class Circle {
    
    /**圓周率*/
    //7常量，不能被修改，靜態成員可以直接訪問
    public static final double PI=3.1415926;
    
    
    /**半徑*/
    //3屬性(成員變量，方法內的變量叫局部變量不能被訪問修飾符)    
    //命名：數字，字母，下划線，$組成；camel 駱駝命名法，首字母小寫，從第2個單詞開始大寫
    //成員變量有默認值，數字一般為0，字符為null
    public int radiusLength;
    
    /**獲得面積*/
    //4方法，完成特定功能的代碼塊
    public double getArea()
    {
        //5局部變量
        double result=PI*radiusLength*radiusLength;
        //將結果返回
        return result;
    }
    
}

類的定義：

package com.zhangguo.c321;

/**類 圓*/
public class Circle {
    /**常量*/
    public final static double PI=3.14;
    
    /**屬性 半徑*/
    public double r;
    
    /**方法 計算面積*/
    public double area(){
        double result=PI*r*r;
        return result;
    }
    
    /**方法 計算周長*/
    public double len(){
        double result=2*PI*r;
        return result;
    }
}

測試：

package com.zhangguo.c321;

public class TestCircle {

    public static void main(String[] args) {
        Circle c1=new Circle();
        c1.r=13.57;
        System.out.println(c1.area());
        System.out.println(c1.len());
        
        Circle c2=new Circle();
        c2.r=89.88;
        System.out.println(c2.area());
        System.out.println(c2.len());
        
    }

}

運行結果：

3.2、實例化對象

類是抽象的，並不能直接使用，將類型實例化后使可以動態應用了。

創建對象的步驟：
a).使用new創建類的一個對象
類型名對象名=new 類型名();

b).使用對象：使用“.”進行以下操作
給類的屬性賦值：對象名.屬性
調用類的方法：對象名.方法名()

package com.gdnf.java.d1;

/**游戲類*/
public class Game {

    /**主方法，程序的入口*/
    public static void main(String[] args) {
        //6對象，實例化對象
        Circle c1=new Circle();
        c1.radiusLength=10;
        
        Circle c2=new Circle();
        c2.radiusLength=5;
        
        //方法調用
        System.out.println(c1.getArea());
        
        System.out.println(c2.getArea());
        
        //靜態的成員屬於類，非靜態成員屬於對象
        //靜態的是公用的，在內存中只有一份
        System.out.println("PI="+Circle.PI+"，"+c1.PI);
        
        
        
    }

}

運行結果：

四、區別引用類型與值類型

五、方法

5.1、類中的成員

類文件中有：包（package）、類（class)、成員變量/屬性（attribute）、方法(method)、常量（const,final）、對象（object)、局部變量（variable）

圓：

//1包
package com.gdnf.java.d1;

//注釋
/**
 *圓
 */
//2類
public class Circle {
    
    /**圓周率*/
    //7常量，不能被修改，靜態成員可以直接訪問
    public static final double PI=3.1415926;
    
    
    /**半徑*/
    //3屬性(成員變量，方法內的變量叫局部變量不能被訪問修飾符)    
    //命名：數字，字母，下划線，$組成；camel 駱駝命名法，首字母小寫，從第2個單詞開始大寫
    //成員變量有默認值，數字一般為0，字符為null
    public int radiusLength;
    
    /**獲得面積*/
    //4方法，完成特定功能的代碼塊
    public double getArea()
    {
        //5局部變量
        double result=PI*radiusLength*radiusLength;
        //將結果返回
        return result;
    }
    
}

客戶端調用：

package com.gdnf.java.d1;

/**游戲類*/
public class Game {

    /**主方法，程序的入口*/
    public static void main(String[] args) {
        //6對象，實例化對象
        Circle c1=new Circle();
        c1.radiusLength=10;
        
        Circle c2=new Circle();
        c2.radiusLength=5;
        
        //方法調用
        System.out.println(c1.getArea());
        
        System.out.println(c2.getArea());
        
        //靜態的成員屬於類，非靜態成員屬於對象
        //靜態的是公用的，在內存中只有一份
        System.out.println("PI="+Circle.PI);
        
        
        
    }

}

運行結果：

//創建對象，c1是對類的對象

Circle c1=new Circle();

//通過對象名訪問對象的屬性“半徑”
c1.radiusLength=10;

對象名.屬性名；

//通過對象名訪問對象的方法getArea()獲得圓的面積

c1.getArea()
對象名.方法名（參數）;

5.2、方法的定義與調用

5.2.1、概要

方法：根據參數完成特定功能的代碼塊

如方法public int add(int n1,int n2)，int是返回值的類型，n1,n2參數，完成的功能相加。

語法：訪問修飾符返回值類型方法名（[參數類型參數名]...）{

方法體

[return 返回值]

}

如果返回值為void則表示沒有返回值，其它情況必須有返回值

package com.gdnf.java.d1;

/**計算器*/
public class Calc {
    
    /**加法方法*/
    public int add(int n1,int n2){
        //返回結果
        return n1+n2;
    }
    
}

調用：

package com.gdnf.java.d1;

/***/
public class Computer {
    public static void main(String[] args) {
        //創建對象
        Calc calc=new Calc();
        System.out.println("1+1="+calc.add(1, 1));
    }
}

5.2.2、沒有返回值的方法

package com.gdnf.java.d1;

/**計算器*/
public class Calc {
    
    /**顯示信息*/
    public void show(String msg){
        System.out.println("神算子計算器告訴你結果："+msg);
    }
    
}

調用：

package com.gdnf.java.d1;

/***/
public class Computer {
    public static void main(String[] args) {
        //創建對象
        Calc calc=new Calc();
        calc.show("1+1="+calc.add(1, 1));
        calc.show(985+"");
    }
}

結果：

當方法的返回值聲明為“void”時方法沒有返回值。

5.2.3、重載

同名的方法不同參數，與返回值沒有關系。

package com.gdnf.java.d1;

/**計算器*/
public class Calc {
    
    /**顯示信息*/
    public void show(String msg){
        System.out.println("神算子計算器告訴你結果："+msg);
    }
    
    /**顯示信息*/
    public void show(Object msg){
        System.out.println("超算子計算器告訴你結果："+msg);
    }
    
    /**加法方法*/
    public int add(int n1,int n2){
        //返回結果
        return n1+n2;
    }
    
}

運行結果：

package com.gdnf.java.d1;

/***/
public class Computer {
    public static void main(String[] args) {
        //創建對象
        Calc calc=new Calc();
        calc.show("1+1="+calc.add(1, 1));
        calc.show(985+"");
        
        
        calc.show(19.8);
        calc.show(true);
        calc.show("1+5=6");
    }
}

運行結果：

方法定義：

package com.gdnf.java.d3;

public class Calc {
    
    public static void main(String[] args) {
        
        $("程序開始");
        
        Calc c=new Calc();
        c.fun(1,100);
        c.fun(1,95);
        c.fun(98,105);
        
        c.fun(1, c.fun(1, 10));
        
        $("程序結束");
    }
    
    public int fun(int s,int e){
        int sum=0;
        for (int i = s; i <=e; i++) {
            sum+=i;
        }
        $(sum);
        return sum;
    }
    
    public static void $(Object str){
        System.out.println("控制台輸出："+str);
    }
    
}

輸出：

控制台輸出：程序開始
控制台輸出：5050
控制台輸出：4560
控制台輸出：812
控制台輸出：55
控制台輸出：1540
控制台輸出：程序結束

六、變量的作用域

a)、方法內可以直接調用成員變量

b)、方法中的局部變量間不允許相互訪問

c)、內部可以無限訪問外部，外部不允許訪問內部，注意靜態

d)、成員變量定義就有默認值，局部變量沒有默認值

package com.gdnf.java.d3;

public class Point {
    
    public int x;
    public int y;
    
    //方法內可以直接調用成員變量
    public void set(int n1,int n2)
    {
        int i=100;
        this.x=n1;
        this.y=n2;
        System.out.println("x:"+this.x+"，y:"+this.y);  //this表示當前對象
    }
    
    public void add(int n3,int n4){
        //i++;  //訪問set方法的i是錯誤的
        int j=0;
        if(n3>100){
            j++;
            int k=0;
            if(n4>200)
            {
                k++;
            }
        }
    }
    
    
}

七、掌握使用static靜態關鍵字

靜態成員屬於類，用類調用，是所有對象共享的。實例成員是獨享。

直接用類名可以獲得靜態成員，當然對象名也可以但不推薦。

package com.gdnf.java.d1;

/**計數器*/
public class Counter {

    public int n1;
    
    public static int n2;
    
    public void show(){
        System.out.println("n1="+n1+"，n2="+n2);
    }
}

調用

package com.gdnf.java.d1;

public class CounterClient {

    public static void main(String[] args) {
        
        Counter c1=new Counter();
        c1.n1++;
        
        Counter c2=new Counter();
        c2.n1++;
        
        c1.show();
        c2.show();
        
    }

}

結果：

package com.gdnf.java.d1;

/**計數器*/
public class Counter {
    //每個實例獨享
    public int n1;
    //所有實例與類共享，只有一份
    public static int n2;
    
    public void show(){
        System.out.println("n1="+n1+"，n2="+n2);
    }
}

調用：

package com.gdnf.java.d1;

public class CounterClient {

    public static void main(String[] args) {
        
        Counter c1=new Counter();
        c1.n2++;
        c1.n1++;
        
        Counter c2=new Counter();
        c2.n2++;
        c2.n1++;
        
        //靜態成員屬於類，直接用類名調用
        Counter.n2++;
        //Counter.n1++;  不允許直接用類名調用非靜態成員
        
        c1.show();
        c2.show();
        
    }

}

結果：

a)、非靜態方法可以直接調用靜態方法

package com.gdnf.java.d1;

/**計數器*/
public class Counter {
    //每個實例獨享
    public int n1;
    //所有實例與類共享，只有一份
    public static int n2;
    
    public void show(){
        show("n1="+n1+"，n2="+n2);
    }
    
    //靜態方法，完成顯示
    public static void show(Object message){
        System.out.println("輸出結果："+message);
    }
    
    //靜態方法，完成減法
    public static void subtract(int n2,int n1){
        //靜態調用靜態 直接
        show("n2-n1="+(n2-n1));
    }
    
    //非靜態方法，完成乘法
    public void  mutil(int n1,int n2){
        //非靜態調用靜態，直接
        show(n1*n2);
    }
    
    
    
    
}

b)、靜態方法不允許直接調用非靜態方法，只能通過對象調用

package com.gdnf.java.d1;

/**計數器*/
public class Counter {
    //每個實例獨享
    public int n1;
    //所有實例與類共享，只有一份
    public static int n2;
    
    public void show(){
        show("n1="+n1+"，n2="+n2);
    }
    
    //靜態方法，完成顯示
    public static void show(Object message){
        System.out.println("輸出結果："+message);
    }
    
    //靜態方法，完成減法
    public static void subtract(int n2,int n1){
        //靜態調用靜態 直接
        show("n2-n1="+(n2-n1));
        
        //靜態不能直接調用非靜態
        //mutil(100,200);  報錯
        //靜態方法可以通過對象名調用非靜態
        Counter counter=new Counter();
        counter.mutil(100,200);
    }
    
    //非靜態方法，完成乘法
    public void  mutil(int n1,int n2){
        //非靜態調用靜態，直接
        show(n1*n2);
    }
    
    
    
    
}

靜態調用非靜態必須通過對象名調用，需實例化對象

package com.gdnf.java.d1;

public class Student {
    
    int i=100;
    public static void main(String[] args) {
        Student tom=new Student();
        System.out.println(tom.i);
    }
    
}

a). static可以修飾：類，變量，方法

b). static修飾的變量只有一個副本

c). static修飾的方法里面不能引用非靜態變量

d). static修飾的方法里面不能引用this關鍵字

e). static方法不能被非靜態方法重寫

八、掌握創建包和導入包

8.1、包的意義

為了更好地組織類，Java 提供了包機制，用於區別類名的命名空間。
包的作用
1、把功能相似或相關的類或接口組織在同一個包中，方便類的查找和使用。分文別類

2、如同文件夾一樣，包也采用了樹形目錄的存儲方式。

3、包也限定了訪問權限，擁有包訪問權限的類才能訪問某個包中的類。

Java 使用包（package）這種機制是為了防止命名沖突，訪問控制，提供搜索和定位類（class）、接口、枚舉（enumerations）和注解（annotation）等。

8.2、定義包

使用package聲明包、一般使和倒置的域名，如com.zhangguo.項目名.具體分類

src上右鍵

輸入包名，不能重復，全部小寫

包與文件夾一一對應：

8.3、導入包

為了能夠使用某一個包的成員，我們需要在 Java 程序中明確導入該包。使用 "import" 語句可完成此功能。

當使用一個類時，如果類不在當前包中則應該先導入包或用全名稱引用。

8.3.1、導入自定義包

第一個Player類：

package com.zhangguo.game;  //包

//玩家類
public class Player {
    //屬性，默認訪問修飾符
    String name;
    
    //展示
    public void show()
    {
        System.out.println("當前玩家是："+this.name);
    }
    
//public
//可以被任何類訪問
    
//protected
//可以被同一包中的所有類訪問
//可以被所有子類訪問
//子類沒有在同一包中也可以訪問
    
//private
//只能夠被當前類的方法訪問
//缺省（無訪問修飾符）

//default 不寫
//可以被同一包中的所有類訪問
//如果子類沒有在同一個包中，也不能訪問
}

第二個Player類：

package com.zhangguo.project;

public class Player {
    public void msg(){
        System.out.println("我是一個運行員");
    }
}

使用：

package com.zhangguo.test;

//導入包，如果是*號則表示包下的所有類
//import com.zhangguo.game.*;
//導入單個類Player
import com.zhangguo.game.Player;

public class PlayerTest {

    public static void main(String[] args) {
        
        //實例化對象
        Player player=new Player();
        //訪問屬性
        player.name="西門吹雪";
        //調用方法
        player.show();
        
        //全名稱引用
        com.zhangguo.project.Player hero=new com.zhangguo.project.Player();
        hero.msg();
    }

}

8.3.2、導入系統包

a)、類中默認引入java.lang.*包，language(語言包)

package com.gdnf.java.d3;

//導入系統已定義好的類
import java.util.Date;

public class Person {

    public static void main(String[] args) {
        System.out.println("Hello java.lang");
        
        Date date=new Date();
        System.out.println("當前時間："+date.toLocaleString());
    }

}

九、Java中的各種修飾符

9.1、類

訪問修飾符修飾符 class 類名稱 extends 父類名稱 implement 接口名稱

（訪問修飾符與修飾符的位置可以互換）

訪問修飾符
名稱	說明	備注
public	可以被所有類訪問（使用）	public類必須定義在和類名相同的同名文件中
package	可以被同一個包中的類訪問（使用）	默認的訪問權限，可以省略此關鍵字，可以定義在和public類的同一個文件中

修飾符
名稱	說明	備注
final	使用此修飾符的類不能夠被繼承
abstract	如果要使用abstract類，之前必須首先建一個繼承abstract類的新類，新類中實現abstract類中的抽象方法。	類只要有一個abstract方法，類就必須定義為abstract，但abstract類不一定非要保護abstract方法不可

9.2、變量

l Java中沒有全局變量，只有方法變量、實例變量（類中的非靜態變量）、類變量（類中的靜態變量）。

l 方法中的變量不能夠有訪問修飾符。所以下面訪問修飾符表僅針對於在類中定義的變量。

l 聲明實例變量時，如果沒有賦初值，將被初始化為null（引用類型）或者0、false（原始類型）。

l 可以通過實例變量初始化器來初始化較復雜的實例變量，實例變量初始化器是一個用{}包含的語句塊，在類的構造器被調用時運行，運行於父類構造器之后，構造器之前。

l 類變量（靜態變量）也可以通過類變量初始化器來進行初始化，類變量初始化器是一個用static{}包含的語句塊，只可能被初始化一次。

訪問修飾符
名稱	說明	備注
public	可以被任何類訪問
protected	可以被同一包中的所有類訪問可以被所有子類訪問	子類沒有在同一包中也可以訪問
private	只能夠被當前類的方法訪問
缺省（無訪問修飾符）	可以被同一包中的所有類訪問	如果子類沒有在同一個包中，也不能訪問

修飾符
名稱	說明	備注
static	靜態變量（又稱為類變量，其它的稱為實例變量）	可以被類的所有實例共享。並不需要創建類的實例就可以訪問靜態變量
final	常量，值只能夠分配一次，不能更改	注意不要使用const，雖然它和C、C++中的const關鍵字含義一樣，可以同static一起使用，避免對類的每個實例維護一個拷貝
transient	告訴編譯器,在類對象序列化時,此變量不需要持久保存	主要是因為改變量可以通過其它變量來得到,使用它是為了性能的問題
volatile	指出可能有多個線程修改此變量，要求編譯器優化以保證對此變量的修改能夠被正確的處理

9.3、方法

訪問修飾符修飾符返回類型方法名稱（參數列表）throws 違例列表

l 類的構造器方法不能夠有修飾符、返回類型和throws子句

l 類的構造器方法被調用時，它首先調用父類的構造器方法，然后運行實例變量和靜態變量的初始化器，然后才運行構造器本身。

l 如果構造器方法沒有顯示的調用一個父類的構造器，那么編譯器會自動為它加上一個默認的super()，而如果父類又沒有默認的無參數構造器，編譯器就會報錯。super必須是構造器方法的第一個子句。

l 注意理解private構造器方法的使用技巧。

訪問修飾符
名稱	說明	備注
public	可以從所有類訪問
protected	可以被同一包中的所有類訪問可以被所有子類訪問	子類沒有在同一包中也可以訪問
private	只能夠被當前類的方法訪問
缺省無訪問修飾符	可以被同一包中的所有類訪問	如果子類沒有在同一個包中，也不能訪問

修飾符
名稱	說明	備注
static	靜態方法（又稱為類方法，其它的稱為實例方法）	提供不依賴於類實例的服務並不需要創建類的實例就可以訪問靜態方法
final	防止任何子類重載該方法	注意不要使用const，雖然它和C、C++中的const關鍵字含義一樣可以同static一起使用，避免對類的每個實例維護一個拷貝
abstract	抽象方法，類中已聲明而沒有實現的方法	不能將static方法、final方法或者類的構造器方法聲明為abstract
native	用該修飾符定義的方法在類中沒有實現，而大多數情況下該方法的實現是用C、C++編寫的。	參見Sun的Java Native接口（JNI），JNI提供了運行時加載一個native方法的實現，並將其於一個Java類關聯的功能
synchronized	多線程的支持	當一個此方法被調用時，沒有其它線程能夠調用該方法，其它的synchronized方法也不能調用該方法，直到該方法返回

9.4、接口

訪問修飾符 interface 接口名稱 extends 接口列表

l接口不能夠定義其聲明的方法的任何實現

l 接口中的變量總是需要定義為“public static final 接口名稱”，但可以不包含這些修飾符，編譯器默認就是這樣，顯示的包含修飾符主要是為了程序清晰

訪問修飾符
名稱	說明
public	所有
無訪問修飾符（默認）	同一個包內

九、下載與視頻

上課視頻B站高清：http://search.bilibili.com/all?keyword=%E5%BC%A0%E6%9E%9C

上課示例下載：http://files.cnblogs.com/files/best/Chapter3.3.7z

十、相關面試題

10.1、在java中我們定義一個類會產生一個后綴為java的文件，請問類中可以包含哪些元素（如類成員）？

　　類文件中有：包（package）、類（class)、成員變量/屬性（attribute）、方法(method)、常量（const,final）、對象（object)、局部變量（variable）

//包
package com.gdnf.java.d3;

//類
public class Animal {
    //構造方法
    public Animal() {
        System.out.println("創建了一個animal對象");
    }
    
    //常量
    public static final double PI=3.14;
    
    //成員變量，字段，屬性
    private int name;
    
    //方法
    public int jump(int n){  //public訪問修飾符,n參數
        //局部變量
        int h=100;
        return n+h;
    }
    
    /**主方法*/
    public static void main(String[] args) {
        //final 不能改
        //static 靜態，靜態的成員屬於類，共享
        //Animal.PI=100;
        
        //非靜態的屬於對象，獨享
        //對象
        //所有的類都是類型
        Animal animal=new Animal();
        
        //方法調用,5表示實參
        int r=animal.jump(50);
        
        System.out.println("動物跳了："+r+"米");
    }
    
}

結果

//包 package 關鍵字  com.gdnf.java.d3 包名
package com.gdnf.java.d3;


//類 
public class Animal {

    //構造方法，創建對象時調用，沒有返回值
    public Animal() {
        System.out.println("創建了一個animal對象");
    }
    
    //常量
    //static 靜態的，靜態的所有對象共享，屬於類，用類名調用
    //final 最終的，不能修改
    public static final double PI=3.14;
    
    //成員變量
    //private 私有的（訪問修飾符）public
    //int 類型（整形）
    //name 變量名稱
    private int name;
    

    //方法
    //int 方法的返回值 return表示向外返回值 void表示不返回
    //int n 參數
    public int jump(int n){  
        //局部變量
        int h=100;
        return n+h; 
    }
    
    /**主方法*/
    public static void main(String[] args) {
        //Animal.PI=100;
        //dog 對象
        //new Animal(); 調用構造方法創建新對象
        //Animal dog; dog類型
        Animal dog=new Animal();
        
        //方法調用
        //r接收返回值
        int r=dog.jump(5);
        System.out.println("狗跳了："+r+"米");
        
        Animal cat=new Animal();
        r=cat.jump(8);
        System.out.println("貓跳了："+r+"米");
    }
    
}

結果

創建了一個animal對象
狗跳了：105米
創建了一個animal對象
貓跳了：108米

10.2、請定義一個汽車（Car）類，在類中添加一個屬性int類型的屬性（speed）。

public class Car{

　　public int speed;

}

10.3、請使用Car類創建兩個對象，實例化兩輛車，一輛名為bmw,一輛名為benz。

package com.gdnf.java.d3;

/**停車場*/
public class Park {

    public static void main(String[] args) {
        Car bmw=new Car();
        Car benz=new Car();
    }

}

10.4、設置bmw與benz的車速分別為198與205

package com.gdnf.java.d3;

/**停車場*/
public class Park {

    public static void main(String[] args) {
        Car bmw=new Car();
        Car benz=new Car();
        bmw.speed=198;
        benz.speed=205;
    }

}

10.5、在Car類中添加一個方法inc實現加速功能，方法中有一個int類型的參數n，當執行方法時把當前車速屬性增長n並輸出到當前車速。

package com.gdnf.java.d3;

//車類
public class Car{
    //速度
    public int speed;
    //加速方法
    public void inc(int n){
        speed=speed+n;
        System.out.println("當前車速："+speed);
    }
}

調用：

package com.gdnf.java.d3;

/**停車場*/
public class Park {

    public static void main(String[] args) {
        Car bmw=new Car();
        Car benz=new Car();
        //訪問屬性
        bmw.speed=198;
        benz.speed=205;
        //調用方法
        bmw.inc(10);
        benz.inc(-5);
    }

}

結果：

10.6、什么是重載？

同名的方法不同參數(類型或個數不同)，與返回值沒有關系，是多態的一種體現。

package com.gdnf.java.d3;

//車類
public class Car {
    // 速度
    public int speed;

    // 加速方法
    public void inc(int n) {
        speed = speed + n;
        System.out.println("當前車速：" + speed);
    }

    // 默認加速
    public void inc() {
        inc(10);
    }

    // 默認加速
    public void inc(int n1, int n2, int n3) {
        inc(n1);
        inc(n2);
        inc(n3);
        System.out.println("多次加速");
    }
}

10.7、靜態方法有什么特點？

a)、使用關鍵字static

b)、靜態的成員屬於類，一般用類名直接調用，無需實例化

c)、非靜態可以直接調用靜態，靜態需通過對象名調用非靜態

d)、靜態是共享的，非靜態是獨享的

package com.gdnf.java.d3;

//車類
public class Car {
    // 速度
    public int speed;

    // 加速方法
    public void inc(int n) {
        speed = speed + n;
        System.out.println("當前車速：" + speed);
        //非靜態可直接調靜態
        run();
    }

    // 默認加速
    public void inc() {
        inc(10);
    }

    // 默認加速
    public void inc(int n1, int n2, int n3) {
        inc(n1);
        inc(n2);
        inc(n3);
        System.out.println("多次加速");
    }
    
    //靜態方法
    public static void run(){
        System.out.println("車正在前行...嘟嘟...");
    }
    
    //靜態方法
    public static void start()
    {
        //靜態調用非靜態實例調用
        Car byd=new Car();
        byd.inc(10);
        
        //靜態直接調靜態
        run();
    }
    
    
    
    
}

測試：

package com.gdnf.java.d3;

/**停車場*/
public class Park {

    public static void main(String[] args) {
        Car bmw=new Car();
        Car benz=new Car();
        //訪問屬性
        bmw.speed=198;
        benz.speed=205;
        //調用方法
        bmw.inc(10);
        benz.inc(-5);
        benz.inc();
        benz.inc();
        
        //靜態方法直接調
        Car.run();
        
        Car qq=new Car();
        qq.speed=100;
        qq.start();
    }

}

結果：

https://www.sojump.hk/m/12759352.aspx?from=timeline

10.8、類成員測試

A卷

1)、請定義一個類Compute，處於包com.zhangguo.chapter3.kaoshi

2)、在類中定義常量PI，默認值為3.1415926

3)、請定義方法isOdd，實現判斷奇數功能，返回boolean類型，輸入int類型

4)、在類中定義一個公有成員變量name，類型為String，初始值為"金算盤計算器"

5)、定義一個靜態方法getArea用於完成圓的面積計算功能，輸入圓的半徑，返回圓的面積

6)、定義一個靜態方法getLength用於完成圓的周長計算功能，輸入圓的半徑，返回圓的周長

7)、定義一個沒有返回值的方法用於顯示信息，方法名為pl，用於替代System.out.println，如pl("hello")，則輸出hello並換行

8)、定義一個類ComputerTest類，添加main方法

9)、實例化兩個Compute對象，c1，c2，測試類中的所有方法與功能

10)、為每一行代碼寫上注釋

B卷

1)、請定義一個類Compute，處於包com.zhangguo.chapter5.kaoshi

2)、在類中定義常量PAI，默認值為3.14

3)、請定義方法isEven，實現判斷偶數功能，返回boolean類型，輸入int類型

4)、在類中定義一個公有成員變量name，類型為String，初始值為"銀算盤計算器"

5)、定義一個靜態方法getArea用於完成圓的面積計算功能，輸入圓的直徑，返回圓的面積

6)、定義一個靜態方法getLength用於完成圓的周長計算功能，輸入圓的直徑，返回圓的周長

7)、定義一個沒有返回值的方法用於顯示信息，方法名為p，用於替代System.out.println，如p("hello")，則輸出hello並換行

8)、定義一個類ComputerTest類，添加main方法

9)、實例化兩個Compute對象，c3，c4，測試類中的所有方法與功能

10)、為每一行代碼寫上注釋

C卷

1)、請定義一個類Compute，處於包com.zhangguo.chapter7.kaoshi

2)、在類中定義常量Pi，默認值為3.1415

3)、請定義方法isFive，實現判斷是否為5的倍數功能，返回boolean類型，輸入int類型，如isFive(15)，返回true

4)、在類中定義一個公有成員變量name，類型為String，初始值為"銅算盤計算器"

5)、定義一個靜態方法getArea用於完成圓的面積計算功能，輸入圓的周長，返回圓的面積

6)、定義一個靜態方法getLength用於完成圓的周長計算功能，輸入圓的半徑，返回圓的周長

7)、定義一個沒有返回值的方法用於顯示信息，方法名為pr，用於替代System.out.println，如pr("hello")，則輸出hello並換行

8)、定義一個類ComputerTest類，添加main方法

9)、實例化兩個Compute對象，c5，c6，測試類中的所有方法與功能

10)、為每一行代碼寫上注釋

參考示例下載：https://files.cnblogs.com/files/best/Chapter3.7z

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Python學習總結（一）—— 十分鍾入門 VUE -- 十分鍾入門 Less 十分鍾帶你入門bootstrap 快速入門：十分鍾學會Python 十分鍾-Nginx 入門到上線十分鍾帶你入門angular 【NLP】十分鍾快覽自然語言處理學習總結【華為雲技術分享】十分鍾從入門到精通（上）—對象存儲服務的OBS權限配置機器學習算法講堂（一）十分鍾入門機器學習算法競賽十分鍾學會防抖和節流