自學Java第五章——《面向對象基礎》

5.1 類與對象

一、類：一類具備相同特性的事物的抽象描述。

對象：類的一個個體，實例，具體的存在。

類是對象的設計模板。

二、如何聲明類？

【修飾符】 class 類名{
    成員列表：屬性、方法、構造器、代碼塊、內部類
}

三、如何建立對象？

new 類名();  //匿名對象
​
類名 對象名 = new 類名(); //有名對象

5.2 類的成員之一：屬性

一、如何聲明屬性？

【修飾符】 class 類名{
    【修飾符】 數據類型  屬性名;    //屬性有默認值
    【修飾符】 數據類型  屬性名 = 值; //屬性有初始值
}

說明：屬性的類型能夠是Java的任意類型，包括基本數據類型、引用數據類型（類、接口、數組等）

 

總結：Java的數據類型

（1）基本數據類型

byte,short,int,long,float,double,char,boolean

（2）引用數據類型

①類：

例如：String、Student、Circle、System、Scanner、Math...

②接口：後面講

③數組：

例如：int[]，String[]，char[]，int[][]

int[] arr = new int[5];
這裏把int[]當作數組類型，是一種引用數據類型，右邊賦值的是一個數組的對象
​
元素的數據類型：int
數組的數據類型：int[]

 

二、如何爲屬性賦值？

（1）在聲明屬性時顯式賦值

【修飾符】 class 類名{
    【修飾符】 數據類型  屬性名 = 值; //屬性有初始值
}

代碼示例：

class Student{
    String name;
    char gender = '男';//顯式賦值
}
​
class TestStudent{
    public static void main(String[] args){
        Student s1 = new Student();
        System.out.println("姓名：" + s1.name);//null
        System.out.println("性別：" + s1.gender);//男
        
        s1.name = "小薇";//修改屬性的默認值
        s1.gender = '女';//修改屬性的初始值
        System.out.println("姓名：" + s1.name);//小薇
        System.out.println("性別：" + s1.gender);//女
        
        Student s2 = new Student();
        System.out.println("姓名：" + s2.name);//null
        System.out.println("性別：" + s2.gender);//男
   }
}

（2）建立對象以後賦值

【修飾符】 class 類名{
    【修飾符】 數據類型  屬性名; //屬性有默認值
}
​
//建立對象
類名 對象名 = new  類名();
​
//爲對象的屬性賦值
對象名.屬性名 = 值;

三、如何訪問屬性的值？

（1）在本類的方法中訪問

示例代碼：

class Circle{
    double radius;
    
    double getArea(){
        return 3.14 * radius * radius;//直接訪問
   }
}

 

（2）在其餘類的方法中訪問

class Circle{
    double radius;
}
​
class TestCircle{
    public static void main(String[] args){
        Circle c1 = new Circle();
        double area = 3.14 * c1.radius * c1.radius;//對象名.屬性名
   }
}

 

四、屬性的特色

（1）屬性有默認值

基本數據類型：

byte,short,int,long：0

float，double：0.0

char：\u0000

boolean：false

引用數據類型：

null

（2）每個對象的屬性是獨立，互不干擾

 

五、對象屬性的內存圖

class Student{
    String name;
    char gender = '男';//顯式賦值
}
​
class TestStudent{
    public static void main(String[] args){
        Student s1 = new Student();
        System.out.println("姓名：" + s1.name);//null
        System.out.println("性別：" + s1.gender);//男
        
        s1.name = "小薇";
        s1.gender = '女';
        System.out.println("姓名：" + s1.name);//小薇
        System.out.println("性別：" + s1.gender);//女
        
        Student s2 = new Student();
        System.out.println("姓名：" + s2.name);//null
        System.out.println("性別：" + s2.gender);//男
   }
}

 

 

5.4 類的成員之二：方法

5.4.1 方法的概念

方法（method）：表明一個獨立的可複用的功能

目的/好處：

（1）複用

（2）簡化代碼

 

5.4.2 方法的語法

一、方法的聲明格式：

【修飾符】 class 類名{
    【修飾符】 返回值類型  方法名(【形參列表】){
        方法體：實現功能的代碼
   }
}

說明：

（1）【修飾符】：待講

（2）返回值類型：

①void：表示無返回值

②非void：全部的Java數據類型均可以

（3）方法名：能很好的體現方法的功能

命名的規範：①見名知意②從第二個單詞開始首字母大寫

（4）【形參列表】：

在完成這個方法的功能時，須要一些數據，這些數據要由「調用者」來決定，那咱們就能夠設計形參。

語法格式：

()：無參，空參

(數據類型 形參名)：一個形參

(數據類型1 形參名1, ......, 數據類型n 形參名n)：n個形參

（5）方法體：實現方法的功能，最好一個方法就完成一個獨立的功能。

 

二、方法的調用格式：

//本類同級別方法調用：直接調用
【變量 = 】 方法名(【實參列表】);

//在其餘類的方法中調用
【變量 = 】 對象名.方法名(【實參列表】);

（1）是否傳實參

看被調用的方法是否有形參

（2）是否接收返回值

看被調用的方法是不是void，若是是void，就不須要也不能接收，若是不是void，就能夠接收。

 

三、方法的聲明與調用的代碼示例

（1）無參無返回值方法

//本類
class Circle{
    double radius;
    void printInfo(){
        System.out.println("半徑：" + radius);
   }
    
    void test(){
        printInfo();//本類中調用無參無返回值方法
   }
}

//其餘類
class Circle{
    double radius;
    void printInfo(){
        System.out.println("半徑：" + radius);
   }
​
}
class TestCircle{
    public static void main(String[] args){
        Circle c1 = new Circle();
        c1.printInfo(); //其餘類中調用無參無返回值方法
   }
}

 

（2）無參有返回值方法

//本類
class Circle{
    double radius;
    
    double getArea(){
        return 3.14 * radius * radius();
   }
    
    void printInfo(){
      // System.out.println("半徑：" + radius + "，面積：" + getArea());//本類中調用無參有返回值
        double area = getArea();//本類中調用無參有返回值
        System.out.println("半徑：" + radius + "，面積：" + area);
   }
}

//其餘類
class Circle{
    double radius;
    
    double getArea(){
        return 3.14 * radius * radius();
   }
}
class TestCircle{
    public static void main(String[] args){
        Circle c1 = new Circle();
        double area = c1.getArea();
        System.out.println("面積：" + area);
        //或
        System.out.println("面積：" + c1.getArea());
   }
}

 

（3）有參無返回值方法

//本類
class GraphicTools{
    void printRectange(int line, int column, char sign){
        for(int i=1; i<=line; i++){
            for(int j=1; j<=column; j++){
                Sytem.out.print(sign);
           }
            System.out.println();
       }
   }
    
    void test(){
        printRectange(5,10,'%');//本類中調用有參無返回值方法
   }
}

//其餘類
class GraphicTools{
    void printRectange(int line, int column, char sign){
        for(int i=1; i<=line; i++){
            for(int j=1; j<=column; j++){
                Sytem.out.print(sign);
           }
            System.out.println();
       }
   }
}
class Test{
    public static void main(String[] args){
        GraphicTools tools = new GraphicTools();
        tools.printRectange(5,10,'%');
   }
}

 

（4）有參有返回值方法

//本類
class MyMath{
    int sum(int a,int b){
        return a+b;
   }
    
    void print(){
        int x = 4;
        int y = 7;
        System.out.println(x + "+" + y + "=" + sum(x,y);//本類中調用有參有返回值的方法
   }
}

//其餘類
class MyMath{
    int sum(int a,int b){
        return a+b;
   }
}
class Test{
    public static void main(String[] args){
        MyMath my = new MyMath();
        int x = 4;
        int y = 7;
        
        System.out.println(x + "+" + y + "=" + my.sum(x,y));
   }
}

 

四、方法聲明與調用的原則

（1）方法必須先聲明後調用

若是調用方法時，若是方法名寫錯或調用一個不存在的方法，編譯會報錯

 

（2）方法聲明的位置必須在類中方法外

正確示例：

類{
    方法1(){
        
   }
    方法2(){
        
   }
}

錯誤示例：

類{
    方法1(){
        方法2(){  //錯誤
        
     }
   }
}

（3）方法的調用的位置有要求

正確示例：

類{
    方法1(){
        調用方法
   }
}

錯誤示例：

類{
    方法1(){
        
   }
    
    調用方法  //錯誤位置
}

（4）方法的調用格式要與方法的聲明格式對應

①是否要加「對象.」：看是否在本類中，仍是其餘類中

②是否要接收返回值：看被調用方法是不是void

③是否要傳實參：看被調用方法是有形參列表

5.4.3 方法的重載Overload

概念：在同一個類中，出現了兩個或多個的方法，它們的方法名稱相同，形參列表不一樣，這樣的形式稱爲方法的重載。和返回值類型無關。

示例代碼：

	//求兩個整數的最大值
public int max(int a,int b){
    return a>b?a:b;
}
	
	//求三個整數的最大值
public int max(int a, int b, int c){
    return max(max(a,b),c);
}
	
	//求兩個小數的最大值
public double max(double a, double b){
    return a>b?a:b;
}

 

5.4.4 方法的參數傳遞機制

Java中方法的參數傳遞機制：值傳遞

（1）形參是基本數據類型時，實參給形參傳遞數據值，是copy的形式，形參對值的修改不影響實參。 （2）形參是引用數據類型時，實參給形參傳遞地址值，形參對對象的屬性的修改，會影響實參對象的屬性值，由於此時形參和實參就是指向同一個對象。 示例代碼：

class Test{
    public static void swap(int a, int b){
        int temp = a;
        a = b;
        b = temp;
 }
​
 public static void main（String[] args){
        int x = 1;
        int y = 2;
        swap(x,y);//調用完以後，x與y的值不變
   }
}
​

示例代碼：

class Test{
    public static void change(MyData my){
        my.num *= 2;
   }
    
    public static void main(String[] args){
        MyData m = new MyData();
        m.num = 1;
        
        change(m);//調用完以後，m對象的num屬性值就變爲2
   }
}
​
class MyData{
    int num;
}

陷阱1：

/*
陷阱1：在方法中，形參 = 新new對象，那麼就和實參無關了
*/
class Test{
    public static void change(MyData my){
        my = new MyData();//形參指向了新對象
        my.num *= 2;
   }
    
    public static void main(String[] args){
        MyData m = new MyData();
        m.num = 1;
        
        change(m);//調用完以後，m對象的num屬性值仍然爲1
   }
}
​
class MyData{
    int num;
}

陷阱2：見字符串和包裝類部分

5.4.5 可變參數的練習

public class srudy {
    public static void main(String[] arge) {
    MyMath my =new MyMath();
    System.out.println("拼接是"+my.con("我是","你","爸爸"));
    System.out.println("5的階乘是"+ my.mutiply(1,2,3,4,5));
    }   
}
class MyMath{
    String con(String...args) {
        String str ="";
        for(int i=0;i<args.length;i++) {
            str+=args[i];
        }
        return str;
    }
    long mutiply(int a,int...num) {
        long result=a;
        for(int i=0;i<num.length;i++) {
            result*=num[i];
        }
        return result; 
    }
}

　　

​

5.4.6 成員變量與局部變量

一、成員變量：

二、局部變量：

（1）初始化不一樣

（2）生命週期不一樣

（3）位置不一樣

①成員變量在堆中 ②局部變量在棧中

（4）聲明的位置不一樣

①成員變量在類的方法之外 ②局部變量在類的方法之內

5.3 對象數組

一維數組：

一、元素是基本數據類型

二、元素是引用數據類型，也稱爲對象數組，即數組的元素是對象

注意：對象數組，首先要建立數組對象自己，即肯定數組的長度，而後再建立每個元素對象，若是不建立，數組的元素的默認值就是null，因此很容易出現空指針異常NullPointerException。

示例代碼：

class MyDate{
    int year;
    int month;
    int day;
}
class Test{
    public static void main(String[] args){
        MyDate[] arr = new MyDate[3];//建立數組對象自己，指定數組的長度
        
        for(int i=0; i<arr.length; i++){
            arr[i] = new MyDate();//每個元素要建立對象
            arr[i].year = 1990 + i;
            arr[i].month = 1 + i;
            arr[i].day = 1 + i;
        }
    }
}
​
​
​
public class srudy {
    public static void main(String[] arge) {
        circle[] arr =new circle[5];
        for(int i=0;i<arr.length;i++) {
            arr[i]=new circle();
            arr[i].R=i+1;
            arr[i].py();
        }
    }   
}
​
class circle{
    double R;
    double getArea() {
        return 3.14*R*R;
    }
    void py() {
        System.out.println("半徑是："+ R +"  面積："+getArea());
    }
}
​

　　

 

練習

package study;
​
public class srudy {
    public static void main(String[] arge) {
        java.util.Scanner input=new java.util.Scanner(System.in);
        Student[] arr=new Student[3];
        for(int i=0;i<arr.length;i++) {
            System.out.print("請輸入"+(i+1)+"成員的信息");
            arr[i]=new Student();
            System.out.print("姓名：");
            arr[i].name=input.next();
            System.out.print("成績：");
            arr[i].score=input.nextInt();
            
        }
        
        for(int i=0;i<arr.length;i++) {
            arr[i].printInfo();
            
        }
        System.out.println("----------------------------");
​
    for(int i=0;i<arr.length;i++) {          //第二種方式
            System.out.println(arr[i].pr());        
        }   
    }
    
}
class Student{
    String name;
    int score;
    void printInfo(){
        System.out.println("姓名"+name+"   成績："+score);
    }
    String pr(){
        return "姓名"+name+"   成績："+score;
    }
}