面向物件編程（基礎）
類與物件
●使用現有技術解決
張老太養了兩只貓貓:一只名字叫小白,今年3歲，白色，還有一只叫小花,今年100歲,花色，請撰寫一個程式，當用戶輸入小貓的名字時,就顯示該貓的名字，年齡，顏色，如果用戶輸入的小貓名錯誤，則顯示張老太沒有這只貓貓，
1)單獨的定義變數解決
2)使用陣列解決
//單獨變數來解決=>平利于資料的管理
//第1只貓資訊
String cat1Name = "小白";
int cat1Age = 3;
String cat1Color ="白色";
//第2只貓資訊
String cat2Name = "小花";int cat2Age = 100;
String cat2Color ="花色";
//陣列===>(1)資料型別體現不出來(2）只能通過[下標]獲取資訊，造成變數名字和內容
// 的對應關系不明確(3）不能體現貓的行為
//第1只貓資訊
String[] cat1 = {"小白","3","白色"};
String[] cat2 ={"小花","100","花色"};
●現有技術解決的缺點分析
不利于資料的管理
效率低
===》 引出我們的新知識點類與物件哲學，道家思想
java設計者引入類與物件(OOP)，根本原因就是現有的技術,不能完美的解決新的新的需求.
●類與物件的關系示意圖
●上圖說明
注意:從貓類到物件，目前有幾種說法:1.創建一個物件⒉.實體化一個物件3.把類實體化...
當然:上面的貓也可是魚、狗、人... java最大的特點就是面向物件，
public class HelloWorld{
public static void main(String []args){
//1. new Cat()創建一只貓
//2.Cat cat1 = new Cat();把創建的貓賦給cat1
//3. cat1就是一個物件
Cat cat1 = new Cat();
cat1.name ="小白";
cat1.age = 3;
cat1.color ="白色";
//創建了第二只貓，并賦給cat2
// cat2 也是一個物件(貓物件)
Cat cat2 = new Cat();
cat2.name ="小花";
cat2.age = 100;
cat2.color ="花色";
//怎么訪問物件的屬性呢
System.out.println("第1只貓資訊" + cat1.name +" " +cat1.age + " "+ cat1.color);
System. out.println("第2只貓資訊"+ cat2.name +" " + cat2.age + " " + cat2.color);
}
}
//使用面向物件的方式來解決養貓問題
//
//定義一個貓類Cat ->自定義的資料型別
class Cat {
//屬性
String name;//名字
int age;//年齡
String color;//顏色
//行為
}
●類和物件的區別和聯系
通過上面的案例和講解我們可以看出:
- 類是抽象的，概念的，代表一類事物,比如人類,貓類.…,即它是資料型別.
- 物件是具體的，實際的，代表一個具體事物,即是實體.
- 類是物件的模板，物件是類的一個個體，對應一個實體.
屬性/成員變數
基本介紹
- 從概念或叫法上看:成員變數=屬性= field(欄位)(即成員變數是用來表示屬性的,授課中，統一叫屬性)，例如: Car(name,price,color)
- 屬性是類的一個組成部分，一般是基本資料型別,也可是參考型別(物件,陣列)，比如我們前面定義貓類的int age就是屬性，
●注意事項和細節說明
-
屬性的定義語法同變數，示例:訪問修飾符屬性型別屬性名;
-
屬性的定義型別可以為任意型別，包含基本型別或參考型別
-
屬性如果不賦值，有默認值，規則和陣列一致，
如何創建物件
- 先宣告再創建
Cat cat ;
cat = new Cat(); - 直接創建
Cat cat = new Cat();
如何訪問屬性
●基本語法
物件名.屬性名;
案例演示賦值和輸出
cat.name ;
cat.age;
cat.color;
類和物件的記憶體分配機制(重要)
●看一個思考題
我們定義一個人類(Person)(包括名字,年齡)，
//我們看看下面一段代碼:
Person p1=new Person();
p1.age=10;
p1.name="小明";
Person p2=p1;//把p1賦給了p2， 讓p2指向p1
System.out.println(p2.age);
//請問:p2.age究竟是多少?并畫出記憶體圖:
//10
●Java記憶體的結構分析
1.堆疊:一般存放基本資料型別(區域變數)
2.堆:存放物件(Cat cat，陣列等)
3.方法區:常量池(常量，比如字串)，類加載資訊
4.示意圖[Cat (name, age, price)
●Java創建物件的流程簡單分析
Person p = new Person();
p.name = "jack” ;
p.age = 10
1.先加載Person類資訊(屬性和方法資訊，只會加載一次)
2在堆中分配空間，進行默認初始化(看規則)
3.把地址賦給p,p就指向物件
4.進行指定初始化，比如p.name =" jack" p.age = 10
●看一個練習題,并分析畫出記憶體布局圖，進行分析
//我們看看下面一段代碼,會輸出什么資訊:
Person a=new Person();
a.age=10;
a.name="小明";
Person b;
b=a;
System.out.println(b.name);
b.age=200;
b = null;
System.out.println(a.age);
System.out.println(b.age);
/*
小明
200
b.age會出現例外.
*/
成員方法
基本介紹
在某些情況下，我們要需要定義成員方法(簡稱方法)，比如人類:除了有一些屬性外(年齡，姓名..),我們人類還有一些行為比如:可以說話、跑步..,通過學習，還可以做算術題，這時就要用成員方法才能完成，現在要求對Person類完善，
●成員方法快速入門
-
添加speak成員方法,輸出我是一只好人
-
添加cal01成員方法,可以計算從1+...+1000的結果
-
添加cal02成員方法,該方法可以接收一個數n，計算從1+...+n 的結果
-
添加getSum成員方法,可以計算兩個數的和
public class HelloWorld{ public static void main(String []args){ //方法使用 //1方法寫好后，如果不去呼叫(使用)，不會輸出 //2．先創建物件,然后呼叫方法即可 Person p1 = new Person(); p1.speak();//呼叫方法 p1.cal01();//呼叫cal01方法 p1.cal02(5);//呼叫cal02方法 //呼叫getSum方法，同時num1=10, num2=20 //把方法 getsum回傳的值，賦給變數 returnRes int returnRes = p1.getSum(10,20); System.out.println("getsum方法回傳的值=" + returnRes); } } class Person { String name; int age; //方法(成員方法) //添加speak成員方法,輸出“我是一個好人” //解讀 //1.public 表示方法是公開 //2.void :表示方法沒有回傳值 //3.speak() : speak是方法名，（)形參串列 //4.方法體，可以寫我們要執行的代碼 //5.System.out.println("我是一個好人");表示我們的方法就是輸出一句話 public void speak(){ System.out.println("我是一個好人"); } //添加cal01 成員方法,可以計算從1+..+1000的結果 public void cal01(){ //回圈完成 int res = 0; for(int i = 1; i <= 1000; i++) { res += i; } System.out.println("計算結果=" + res); } //添加cal02成員方法,該方法可以接收一個數n，計算從1+...+n的結果 //解讀 //1. (int n)形參串列,表示當前有一個形參n，可以接收用戶輸入 public void cal02(int n){ //回圈完成 int res = 0; for(int i = 1; i <= n; i++){ res += i; } System.out.println("cal02計算結果="+ res); } //添加getsum成員方法,可以計算兩個數的和//老韓解讀 //1. public 表示方法是公開的 //2. int :表示方法執行后，回傳一個int 值 // 3. getsum方法名 //4. (int num1, intTum2）形參串列，2個形參，可以接收用戶傳入的兩個數 public int getSum(int num1, int num2) { int res = num1 +num2; return res; } }
● 方法的呼叫機制原理:(重要!-示意圖)
提示:畫出程式執行程序[getSum]+說明
方法呼叫小結
- 當程式執行到方法時，就會開辟一個獨立的空間(堆疊空間)
- 當方法執行完畢，或者執行到return陳述句時，就會回傳
- 回傳到呼叫方法的地方
- 回傳后，繼續執行方法后面的代碼
為什么需要成員方法
●看一個需求:
請遍歷一個陣列，輸出陣列的各個元素值，
?解決思路1，傳統的方法，就是使用單個for回圈，將陣列輸出，大家看看問題是什么?
?解決思路2:定√義一個類 MyTools ，然后寫一個成員方法，呼叫方法實作,看看效果又如何，
成員方法的好處
?提高代碼的復用性
?可以將實作的細節封裝起來,然后供其他用戶來呼叫即可.
成員方法的定義
訪問修飾符 回傳資料型別 方法名 (形參串列..){//方法體
陳述句;
return 回傳值;
}
- 形參串列:表示成員方法輸入 cal(int n),getSum(int num1, int num2)
- 回傳資料型別:表示成員方法輸出;void表示沒有回傳值
- 方法主體:表示為了實作某一功能代碼塊
- return 陳述句不是必須的，
- 提示：結合前面的題示意圖,來理解
注意事項和使用細節
●訪問修飾符(作用是控制方法使用的范圍)
可選,[有四種:?],具體在后面說
●回傳型別
- 一個方法最多有一個回傳值[思考，如何回傳多個結果?]
- 回傳型別可以為任意型別,包含基本型別或參考型別(陣列，物件)
- 如果方法要求有回傳資料型別，則方法體中最后的執行陳述句必須為return值;而且要求回傳值型別必須和return的值型別一致或兼容（回傳資料支持自動型別轉換）
- 如果方法是void，則方法體中可以沒有return陳述句,或者只寫 return;
●方法名
遵循駝峰命名法，最好見名知義，表達出該功能的意思即可,比如得到兩個數的和getSum,開發中按照規范
●形參串列
- 一個方法可以有0個引數，也可以有多個引數，中間用逗號隔開,比如getSum(int n1,int n2)
- 引數型別可以為任意型別，包含基本型別或參考型別，比如printArr(int[][] map)
- 呼叫帶引數的方法時，一定對應著引數串列傳入相同型別或兼容型別的引數! 【getSum】（傳入資料支持自動型別轉換）
- 方法定義時的引數稱為形式引數，簡稱形參;方法呼叫時的引數稱為實際引數，簡稱實參,實參和形參的型別要一致或兼容、個數、順序必須一致![演示]
●方法體
里面寫完成功能的具體的陳述句,可以為輸入、輸出、變數、運算、分支、回圈、方法呼叫，但里面不能再定義方法!即:方法不能嵌套定義，[演示]
注意事項和使用細節
●方法呼叫細節說明
- 同一個類中的方法呼叫:直接呼叫即可，比如print(引數);案例演示:A類 sayOk呼叫print()
- 跨類中的方法A類呼叫B類方法:需要通過物件名呼叫，比如物件名.方法名(引數);案例演示:B類 sayHello 呼叫print()
- 特別說明一下:跨類的方法呼叫和方法的訪問修飾符相關，先暫時這么提一下,后面我們講到訪問修飾符時,還要再細說，
成員方法傳參機制
方法的傳參機制對我們今后的編程非常重要，一定要搞的清清楚楚明明白白，我們通過案例來學習，
●基本資料型別的傳參機制
public class HelloWorld{
public static void main(String []args){
int a = 10;int b = 20;
//創建AA物件名字 obj
AA obj = new AA();
obj.swap(a,b);//呼叫swap
System.out.println( "main方法a=" +a+ " b=" + b); //a=10 b=20
}
}
class AA {
//同一個類中的方法呼叫:直接呼叫即可/ /
public void swap(int a,int b) {
System.out. println("\na和b交換前的值\na=" + a + "\tb=" + b);//a=10 b=20
//完成了a 和b的交換
int tmp = a;
a = b;
b = tmp;
System.out.println("\na和b交換后的值\na=" + a + "\tb=" + b);//a=20 b=10
}
}
//swap方法會創建不同的堆疊，其中的變數a,b所對應的地址也不同，因此不會改變，
●參考資料型別的傳參機制
- 看一個案例
B類中撰寫一個方法test100，可以接收一個陣列，在方法中修改該陣列，看看原來的陣列是否變化?
public class HelloWorld{
public static void main(String []args){
//測驗
B b = new B();
int[ ] arr = {1,2,3};
b.test100(arr);//呼叫方法
System.out. println( " main的arr陣列");//逼歷陣列
for(int i = 0; i < arr. length; i++) {
System.out.print(arr[i] +"\t");
}
System.out.println();
}
}
class B {
//B類中撰寫一個方法test100,
//可以接收一個陣列，在方法中修改該陣列，看看原來的陣列是否變化
public void test100(int[] arr) {
arr[0] = 200;//修改元素
//遍歷陣列
System.out.println( "test100的arr陣列");
for(int i = 0; i <arr. length; i++){
System.out.print(arr[i] +"\t");
}
}
}
//陣列為應用型別，呼叫test100產生新堆疊時傳入的是arr在堆中的地址而不是拷貝陣列，因此修改arr時是對同一空間進行操作，所以會改變
- B類中撰寫一個方法test200，可以接收一個Person(age,sal)物件，在方法中修改該物件屬性，看看原來的物件是否變化? //會變化
// import java.util.Scanner;
public class HelloWorld{
public static void main(String []args){
B b = new B();
Person p = new Person();
p.name = "jack" ;
p.age = 10;
b.test200(p);
System.out.println( "main的p.age=" + p.age);
}
}
class Person {
String name;
int age;
}
class B {
public void test200 (Person p) {
p.age = 10000;//修改物件屬性
}
}
- 再看一個案例,下面的方法會對原來的物件有影響嗎?
在test200方法中設定p=null 和p = new Person();
//結果不變，main中p. age為10，因為此處只是修改test200開辟的堆疊中的p的指向，并未改變main中p的指向，
方法遞回呼叫(難點，為演算法入門，可占時跳過)
●基本介紹
簡單的說:遞回就是方法自己呼叫自己,每次呼叫時傳入不同的變數.遞回有助于編程者解決復雜問題,同時可以讓代碼變得簡潔
遞回能解決什么問題?
- 各種數學問題如:8皇后問題，漢諾塔，階乘問題,迷宮問題,球和籃子的問題(google編程大賽)[經典問題，網上答案很多]
- 各種演算法中也會使用到遞回，比如快排，歸并排序,二分查找,分治演算法等.3.將用堆疊解決的問顆-->詳歸代碼比較簡潔
●八皇后問題說明
八皇后問題,是一個古老而著名的問題,，是回溯演算法的典型案例，該問題是國際西洋棋棋手馬克斯·貝瑟爾于1848年提出:在8×8格的國際象棋上擺放八個皇后,使其不能互相攻擊,即:任意兩個皇后都不能處于同一行、同一列或同一斜線上，問有多少種擺法，
/*
●八皇后思路分析，老韓說下
1)第一個皇后先放第一行第一列
2)第二個皇后放在第二行第一列、然后判斷是否OK，如果不OK，繼、續放在第二列、第三列、依次把所有列都放完，找到一個合適
3)繼續第三個皇后，還是第一列、第二列.…..直到第8個皇后也能放在一個不沖突的位置,算是找到了一個正確解
4)當得到一個正確解時，在堆疊回退到上一個堆疊時，就會開始回溯，即將第一個皇后，放到第一列的所有正確解,全部得到.
5)然后回頭繼續第一個皇后放第二列，后面繼續回圈執行1,2.3.4的步驟
說明:理論上應該創建一個二維陣列來表示棋盤,但是實際上可以通過演算法，用一個一維陣列即可解決問題. arr[8] ={0，4, 7,5.2,6,1,3}//對應arr下標表示第幾行，即第幾個皇后，arri] = val , val表示第i+1個皇后，放在第i+1行的第val+1列
*/
public class HelloWorld{
public static void main(String []args){
B b = new B();
int huang[]=new int[8];
System.out.println(b.test200(huang,0));
}
}
class B {
public int test200 (int[] huang,int i) {
if(i>7){
return 1;
}else{
int m=0;
for(int j=1;j<=8;j++){
if(aa(huang,j,i)){//不沖突
huang[i]=j;
m+=test200(huang, i+1);
}
}
return m;
}
}
public boolean aa(int[] huang,int a,int b){//是否已經存在
for(int i=0;i<b;i++){
if(a==huang[i] || (a-huang[i]==b-i) || (a-huang[i]==i-b)){
return false;
}
}
return true;
}
}
方法多載（overload）
●基本介紹
java中允許同一個類中，多個同名方法的存在,但要求形參串列不一致!比如:System.out.println); out是PrintStream型別
●多載的好處
- 減輕了起名的麻煩
- 減輕了記名的麻煩
●快速入門案例
public class HelloWorld{
public static void main(String []args){
MyCalculator mc = new MyCalculator();
System.out.println(mc.calculate(1,2));
System.out.println(mc.calculate(1,2.1));
}
}
class MyCalculator {
//下面的四個calculate方法構成了多載
//兩個整數的和
public int calculate(int n1, int n2){
return n1 +n2;
}
//一個整數,一個double的和
public double calculate(int n1,double n2) {
return n1 + n2;
}
//一個double ,一個工t和
public double calculate(double n1,int n2) {
return n1 + n2;
}
//三個int的和
public int calculate(int n1,int n2,int n3) {
return n1 + n2 + n2;
}
}
●注意事項和使用細節
- 方法名:必須相同
- 引數串列:必須不同(引數型別或個數或順序，至少有一樣不同，引數名無要求)
- 回傳型別:無要求
可變引數
●基本概念
java允許將同一個類中多個同名同功能但引數個數不同的方法，到裝成一個方法，就可以通過可變引數實作
●基本語法
訪問修飾符 回傳型別 方法名(資料型別... 形參名){
}
●快速入門案例
public class HelloWorld{
public static void main(String []args){
HspMethod m = new HspMethod();
int sum=m.sum(1,5,100);
System.out.println(sum);
}
}
class HspMethod {
//1. int...表示接受的是可變引數，型別是int ,即可以接收多個1nt(0-多)
//2，使用可變引數時，可以當做陣列來使用即nums可以當做陣列
public int sum( int... nums){
System.out.println("接收的引數個數="+ nums. length);
int res = 0;
for(int i = 0; i < nums. length;i++){
res += nums[i];
}
return res;
}
}
●注意事項和使用細節
- 可變引數的實參可以為0個或任意多個，
- 可變引數的實參可以為陣列，
- 可變引數的本質就是陣列.
- 可變引數可以和普通型別的引數一起放在形參串列，但必須保證可變引數任最后
- 一個形參串列中只能出現一個可變引數
//細節:可變引數可以和普通型別的引數一起放在形參串列，但必須保證可變引數在最后
public void f2(String str,doubLe... nums) {
}
//細節:一個形參串列中只能出現一個可變引數//下面的寫法是錯的·
// public void f3(int. .. nums1,double. . . nums2) {}
作用域
●基本使用
面向物件中，變數作用域是非常重要知識點，相對來說不是特別好理解，要求深刻掌握變數作用域，
- 在java編程中，主要的變數就是屬性(成員變數)和區域變數，
- 我們說的區域變數一般是指在成員方法中定義的變數，【舉例Cat類:cry)
- Java中作用域的分類
全域變數:也就是屬性，作用域為整個類體Cat類:cry eat等方法使用屬性
區域變數:也就是除了屬性之外的其他變數，作用域為定義它的代碼塊中! - 全域變數(屬性)可以不賦值，直接使用，因為有默認值，區域變數必須賦值后，才能使用，因為沒有默認值，
注意事項和細節使用
- 屬性和區域變數可以重名,訪問時遵循就近原則，
- 在同一個作用域中，比如在同一個成員方法中，兩個區域變數，不能重名，
- 屬性生命周期較長，伴隨著物件的創建而創建，伴隨著物件的銷毀而銷毀，區域變數,生命周期較短，伴隨著它的代碼塊的執行而創建，伴隨著代碼塊的結束而銷毀，即在一次方法呼叫程序中，\
class Person {
String name = "jack";
public void say() {
//細節屬性和區域變數可以重名,訪問時遵循就近原則
String name= "king";
System.out. println( "say() name=" +name);
}
public void hi(){
String address ="北京";
// String address =“上海";//錯誤,重復定義變數
String name= "hsp";
}
}
- 作用域范圍不同
全域變數/屬性:可以被本類使用，或其他類使用(通過物件呼叫)
區域變數;只能在本類中對應的方法中使用 - 修飾符不同
全域變數/屬性可以加修飾符
區域變數不可以加修飾符
構造方法/構造器
●看一個需求
我們來看一個需求:前面我們在創建人類的物件時，是先把一個物件創建好后，再給他的年齡和姓名屬性賦值，如果現在我要求，在創建人類的物件時，就直接指定這個物件的年齡和姓名,該怎么做?這時就可以使用構造器，
●基本語法
[修飾符] 方法名(形參串列){
方法體;
}
說明:
- 構造器的修飾符可以默認
- 構造器沒有回傳值
- 方法名和類名字必須一樣
- 引數串列和成員方法一樣的規則
- 構造器的呼叫系統完成
基本介紹
構造方法又叫構造器(constructor)，是類的一種特殊的方法,它的主要作用是完成對新物件的初始化，它有幾個特點:
- 方法名和類名相同
- 沒有回傳值
- 在創建物件時,系統會自動的呼叫該類的構造器完成物件的初始化，
快速入門
現在我們就用構造方法來完成剛才提出的問題:在創建人類的物件時，就直接指定這個物件的年齡和姓名
public class HelloWorld{
public static void main(String []args){
//當我們new 一個物件時，直接通過構造器指定名字和年齡
Person p1 = new Person( "smith",80);
System.out.println( "p1的資訊如下");
System.out.println( "p1物件name=" + p1.name); // smith
System.out.println( "p1物件age=" + p1.age);//80
}
}
//在創建人類的物件時，就直接指定這個物件的年齡和姓名
//
class Person {
String name;
int age;
//構造器//老韓解讀
//1，構造器沒有回傳值,也不能寫void
//2，構造器的名稱和類Person—樣
//3.(String pName, int pAge）是構造器形參串列，規則和成員方法―樣
public Person(String pName, int pAge){
System.out.println("構造器被呼叫~~完成物件的屬性初始化");
name = pName;
age = pAge;
}
public Person(String pName){
System.out.println("構造器多載---");
name = pName;
}
}
●注意事項和使用細節
- 一個類句以定義多個不同的構造器,即構造器多載
比如:我們可以再給Person類定義一個構造器,用來創建物件的時候,只指定人名,不需要指定年齡 - 構造器名和類名要相同3.構造器沒有回傳值
- 構造器是完成物件的初始化.并不是創建物件
- 在創建物件時，系統自動的呼叫該類的構造方法
- 如果程式員沒有定義構造器，系統會自動給類生成一個默認無參構造器(也叫默認構造器)，比如Dog (){},使用javap指令反編譯看看
- 一旦定義了自己的構造器,默認的構造器就覆寫了，就不能再使用默認的無參構造器,除非顯式的定義一下,即: Person(){}
this
●先看一段代碼,并分析問題
public class HelloWorld{
public static void main(String []args){
Dog dog1 = new Dog("大壯",3);
dog1.info();
}
}
class Dog{//類
String name;
int age;
// public Dog (String dName,int dAge){//構造器/ /name = dName;
//age = dAge;/ / }
//如果我們構造器的形參，能夠直接寫成屬性名,就更好了
//但是出現了一個問題,根據變數的作用域原則
//構造器的name是區域變數,而不是屬性
//構造器的age是區域變數,而不是屬性
//==>引出this關鍵字來解決
public Dog (String name, int age){//構造器
name = name;
age = age;
}
public void info(){//成員方法,輸出屬性×資訊
System.out.println(name + "\t" +age + "\t");
}
}
●什么是this
java虛擬機會給每個物件分配this,代表當前物件，
●使用this解決前面變數命名問題
public class HelloWorld{
public static void main(String []args){
Dog dog1 = new Dog("大壯",3);
dog1.info();
}
}
class Dog{//類
String name;
int age;
// public Dog (String dName,int dAge){//構造器/ /name = dName;
//age = dAge;/ / }
//如果我們構造器的形參，能夠直接寫成屬性名,就更好了
//但是出現了一個問題,根據變數的作用域原則
//構造器的name是區域變數,而不是屬性
//構造器的age是區域變數,而不是屬性
//==>引出this關鍵字來解決
public Dog (String name, int age){//構造器
//this.name就是當前物件的屬性name
this.name = name;
//this.age就是當前物件的屬性age
this.age = age;
}
public void info(){//成員方法,輸出屬性×資訊
System.out.println(name + "\t" +age + "\t");
}
}
this小結:簡單的說,哪個物件呼叫，this就代表哪個物件
this的注意事項和使用細節
-
this關鍵字可以用來訪問本類的屬性、方法、構造器
-
this用于區分當前類的屬性和區域變數
class Dog{//類
String name;
int age;
public Dog (String name, int age){//構造器
//this.name就是當前物件的屬性name
this.name = name;
//this.age就是當前物件的屬性age
this.age = age;
}
}
-
訪問成員方法的語法:this.方法名(引數串列);注意:訪問構造器語法:this(引數串列);必須放置第一條陳述句
/* 細節:訪問構造器語法:this(引數串列); 注意只能在構造器中使用(即只能在構造器中訪問另外一個構造器) 注意:訪問構造器語法:this(引數串列);必須放置第一條陳述句 */ public T(){ this("jack",100);//這里去訪問 T(String name,int age) System.out.print1n("T()構造器"); } public T(String name, int age) { System.out.println("T(String name,int age）構造器"); } -
訪問構造器語法:this(引數串列);注意只能在構造器中使用5. this不能在類定義的外部使用，只能在類定義的方法中使用，
●this的課堂案例
定義Person類，里面有name、age屬性，并提供compareTo比較方法，用于判斷是否和另一個人相等，提供測驗類TestPerson用于測驗名字和年齡完全一樣，就回傳true,否則回傳false
public class HelloWorld{
public static void main(String []args){
Person p1 =new Person( "mary" ,20);
Person p2 =new Person( "smith", 30);
System.out.println(p1.compareTo(p2));
}
}
class Person{//類
String name;
int age;
public Person(String name,int age){
this.name=name;
this.age=age;
}
public boolean compareTo(Person p){
return (this.name.equals(p.name)&& this.age==p.age);
}
}
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/499334.html
標籤：其他