java基礎-面向對象(一)

java的傳遞機制

重點、難點
* 方法的參數傳遞（重點、難點）
 * 1.形參：方法聲明時，方法小括號內的參數
 *   實參：調用方法時，實際傳入的參數的值
 *   
 * 2.規則：java中的參數傳遞機制：值傳遞機制
 *   1）形參是基本數據類型的：將實參的值傳遞給形參的基本數據類型的變量
 *   2）形參是引用數據類型的：將實參的引用類型變量的值（對應的堆空間的對象實體的首地址值）傳遞給形參的引用類型變量。
 
【典型例題1】


public static void main(String[] args) {
TestArgsTransfer tt = new TestArgsTransfer();

int i = 10;
int j = 5;
System.out.println("i:" + i + " j:" + j);//i : 10  j : 5

// //交換變量i與j的值
// int temp = i;
// i = j;
// j = temp;
tt.swap(i, j);//將i的值傳遞給m，j的值傳遞給n


System.out.println("i:" + i + " j:" + j);//i : 10  j : 5

}
//定義一個方法，交換兩個變量的值
public void swap(int m,int n){
int temp = m;
m = n;
n = temp;
System.out.println("m:" + m + " n:" + n);


}



使用swap方法以後：



【典型例題2】
public class TestArgsTransfer1 {
public static void main(String[] args) {
TestArgsTransfer1 tt = new TestArgsTransfer1();
DataSwap ds = new DataSwap();

System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);

tt.swap(ds);
System.out.println(ds);

System.out.println("ds.i:" + ds.i + " ds.j:" + ds.j);

}
//交換元素的值
public void swap(DataSwap d){
int temp = d.i;
d.i = d.j;
d.j = temp;
System.out.println(d);//打印引用變量d的值
}
}


class DataSwap{
int i = 10;
int j = 5;
}

package和import

/*
 * package:聲明源文件所在的包，寫在程序的第一行。
 *   每“.”一次，表示一層文件目錄。
 *   包名都要小寫。
 *   
 * import:
 * 1)顯式導入指定包下的類或接口
 * 2)寫在包的聲明和源文件之間
 * 3)如果需要引入多個類或接口，那麼就並列寫出
 * 4)如果導入的類是java.lang包下的，如：System String Math等，就不需要顯式的聲明。
 * 5)理解.*的概念。比如java.util.*;
 * 6)如何處理同名類的導入。如：在util包和sql包下同時存在Date類。
 * 7)import static 表示導入指定類的static的屬性或方法
 * 8)導入java.lang.*只能導入lang包下的所有類或接口，不能導入lang的子包下的類或接口
 */
//import java.util.Scanner;
//import java.util.Date;
//import java.util.List;
//import java.util.ArrayList;
import java.lang.reflect.Field;
import java.util.*;
import static java.lang.System.*;
public class TestPackageImport {
public static void main(String[] args) {
out.println("helloworld");
Scanner s = new Scanner(System.in);
s.next();

Date d = new Date();
List list = new ArrayList();

java.sql.Date d1 = new java.sql.Date(522535114234L);

Field f = null;
}
}

this關鍵字

this：
1.使用在類中，可以用來修飾屬性、方法、構造器
2.表示當前對象或者是當前正在創建的對象
3.當形參與成員變量重名時，如果在方法內部需要使用成員變量，必須添加this來表明該變量時類成員
4.在任意方法內，如果使用當前類的成員變量或成員方法可以在其前面添加this，增強程序的閱讀性
5.在構造器中使用“this(形參列表)”顯式的調用本類中重載的其它的構造器
   >5.1 要求“this(形參列表)”要聲明在構造器的首行！
   >5.2 類中若存在n個構造器，那麼最多有n-1構造器中使用了this。


public class TestPerson {
public static void main(String[] args) {
Person p1 = new Person();
System.out.println(p1.getName() + ":" + p1.getAge());

Person p2 = new Person("BB",23);
int temp = p2.compare(p1);
System.out.println(temp);
}
}
class Person{

private String name;
private int age;

public Person(){
this.name = "AA";
this.age = 1;
}

public Person(String name){
this();
this.name = name;
}
public Person(String name,int age){
this(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 eat(){
System.out.println("eating");
}
public void sleep(){
System.out.println("sleeping");
this.eat();
}
//比較當前對象與形參的對象的age誰大。
public int compare(Person p){
if(this.age > p.age)
return 1;
else if(this.age < p.age)
return -1;
else
return 0;
}

}

方法的重載

 * 方法的重載（overload）
 * 要求：1.同一個類中 2.方法名必須相同 3.方法的參數列表不同（①參數的個數不同②參數類型不同）
 * 補充：方法的重載與方法的返回值類型沒有關係！


//如下的四個方法構成重載
//定義兩個int型變量的和
public int getSum(int i,int j){
return i + j;
}
//定義三個int型變量的和
public int getSum(int i,int j,int k){
return i + j + k;
}
//定義兩個double型數據的和
public double getSum(double d1,double d2){
return d1 + d2;
}


//定義三個double型數組的和
public void getSum(double d1,double d2,double d3){
System.out.println(d1 + d2 + d3);
}
//不能與如上的幾個方法構成重載
// public int getSum1(int i,int j,int k){
// return i + j + k;
// }
// public void getSum(int i,int j,int k){
// System.out.println(i + j + k);
// }




//以下的兩個方法構成重載。
public void method1(int i,String str){

}
public void method1(String str1,int j){

}

構造器

 * 一、類的第三個成員：構造器(constructor 構造方法)   construction  CCB  ICBC   oop
 * constructor:建造者 
 * 構造器的作用：①創建對象 ②給創建的對象的屬性賦值
 * 
 * 1.設計類時，若不顯式聲明類的構造器的話，程序會默認提供一個空參的構造器.
 * 2.一旦顯式的定義類的構造器，那麼默認的構造器就不再提供。
 * 3.如何聲明類的構造器。格式：權限修飾符  類名(形參){ }
 * 4.類的多個構造器之間構成重載




 * 二、類對象的屬性賦值的先後順序：①屬性的默認初始化 ②屬性的顯式初始化③通過構造器給屬性初始化
 *   ④通過"對象.方法"的方式給屬性賦值

可變個數的形參的方法

 * 可變個數的形參的方法：
 * 1.格式：對於方法的形參： 數據類型 ... 形參名
 * 2.可變個數的形參的方法與同名的方法之間構成重載
 * 3.可變個數的形參在調用時，個數從0開始，到無窮多個都可以。
 * 4.使用可變多個形參的方法與方法的形參使用數組是一致的。
 * 5.若方法中存在可變個數的形參，那麼一定要聲明在方法形參的最後。
 * 6.在一個方法中，最多聲明一個可變個數的形參。




//如下四個方法構成重載
//在類中一旦定義了重載的可變個數的形參的方法以後，如下的兩個方法可以省略
// public void sayHello(){
// System.out.println("hello world!");
// }
// public void sayHello(String str1){
// System.out.println("hello " + str1);
// }
//可變個數的形參的方法
public void sayHello(String ... args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i] + "$");
}
//System.out.println("=====");
}

public void sayHello(int i,String ... args){
//public void sayHello(String ... args,int i){
System.out.println(i);

for(int j = 0;j < args.length;j++){
System.out.println(args[j] + "$");
}
}

public void sayHello1(String[] args){
for(int i = 0;i < args.length;i++){
System.out.println(args[i]);
}
}

類及對象

1.關於於類的設計


2.類的組成成分：
   1） 屬性（成員變量，Field）
   2）方法（成員方法，函數，Method）


2.1屬性：
     *   成員變量 vs 局部變量
 *   相同點：1.遵循變量聲明的格式： 數據類型 變量名 = 初始化值
 *       2.都有作用域
 *   不同點：1.聲明的位置的不同 ：成員變量：聲明在類裏，方法外
 *        局部變量：聲明在方法內，方法的形參部分，代碼塊內
 *         2.成員變量的修飾符有四個：public private protected 缺省
 *           局部變量沒有修飾符，與所在的方法修飾符相同。
 *         3.初始化值：一定會有初始化值。
 *          成員變量:如果在聲明的時候，不顯式的賦值，那麼不同數據類型會有不同的默認初始化值。
 *            byte short int long ==>0
 *            float double ==>0.0
 *            char ==>空格
 *            boolean ==>false 
 *            引用類型變量==>null
 *          局部變量：一定要顯式的賦值。（局部變量沒有默認初始化值）
 *         4.二者在內存中存放的位置不同:成員變量存在於堆空間中；局部變量：棧空間中
 *         
 * 總結：關於變量的分類：1）按照數據類型的不同：基本數據類型（8種）  & 引用數據類型
 *    2）按照聲明的位置的不同：成員變量 & 局部變量


2.2 方法：提供某種功能的實現
 *    1）實例：public void eat(){//方法體}
 *           public String getName(){}
 *           public void setName(String n){}
 *      格式：權限修飾符 返回值類型（void:無返回值/具體的返回值） 方法名(形參){}
 *      
 *    2)關於返回值類型：void：表明此方法不需要返回值
 *       有返回值的方法：在方法的最後一定有return + 返回值類型對應的變量
 *       記憶：void 與return不可以同時出現一個方法內。像一對“冤家”。
 * 
 *   3)方法內可以調用本類的其他方法或屬性，但是不能在方法內再定義方法！


3.面向對象編程的思想的落地法則一：
1）設計並創建類及類的成分
2）實例化類的對象
3）通過“對象.屬性”或"對象.方法"的形式完成某項功能


4.類的初始化的內存解析
4.1  內存劃分的結構：
      棧(stack):局部變量 、對象的引用名、數組的引用名
      堆(heap):new 出來的“東西”（如：對象的實體，數組的實體），含成員變量
      方法區:含字符串常量
      靜態域：聲明爲static的變量

面向對象的特徵-封裝和隱藏

 * 一、面向對象的特徵一：封裝與隱藏
 * 問題：當創建了類的對象以後，如果直接通過"對象.屬性"的方式對相應的對象屬性賦值的話，可能會出現不滿足實際
 * 情況的意外，我們考慮不讓對象來直接作用屬性，而是通過"對象.方法"的形式，來控制對象對屬性的訪問。實際
 * 情況中，對屬性的要求就可以通過方法來體現。
 * 
二、面向對象思想的落地法則二：
（封裝性的思想）①將類的屬性私有化，②提供公共的方法（setter & getter）來實現調用。


三、四種權限修飾符
1.權限從大到小爲：public   protected   缺省   private  
2.四種權限都可以用來修飾屬性、方法、構造器
3.修飾類的話：public 缺省




修飾符    內部類    同一個包    子類   任何地方


private     yes   


（缺省）    yes      yes


protected   yes      yes        yes


public      yes      yes        yes      yes




*對於class的權限修飾只可以用在public和default（缺省）
*public類可以在任意地方唄訪問
*default類只可以唄同一個包內部的類訪問