面向對象基礎2

 

Code:
  1.    
  2.   
  3.        棧--à對象名  
  4.        堆--à對象屬性  
  5.        全局代碼區--à所有的方法  
  6. 訪問屬性或方法;一、對象.屬性   對象.方法  
  7. 類中方法的使用 一個類中可以定義多個方法,這些類內部的方法之間可以互相調用,當然在調用前也可以加上一個this關鍵字,表示當前類之中的方法,即:this.方法名稱()  
  8. This 表示本類中的屬性 採用setXxx()和getXxx()方法對私有變量的操作  
  9.    
  10. 構造方法 1、具有與類相同的名稱 2、它不含返回值類型的定義 3、它不能在方法中用return 語句返回一個值。  
  11.    
  12. 構造方法的定義; class Person{  
  13.  Public Person(){};  
  14. }  
  15. 構造方法調用時機   構造方法在實例化對象時被自動調用,主要用來爲類中的屬性初始化  
  16.                                    構造方法的重載 與一般方法重載類似,只要參數的個數類類型不同即可。  
  17.    
  18. 構造方法是在對象實例化時被自動調用 對象實例化需要通過new關鍵字  
  19. 對象產生的格式; 類 對象名 = new 類();  
  20.                                    類():調用類中的構造方法  
  21. 在java之中每個類必須有一個構造方法,如果沒有構造方法,則會自得生成一個無參的什麼都不做的構造方法,因爲所有的對象產生時都必須調用構造方法 如果程序中已經明確寫出了構造方法,則不會再產生一個無參的什麼都不做的構造方法。  
  22.    
  23. 結論:無論採用那種方法爲類中的發生賦值,最好都經過setter 方法,由setter 方法對輸入的內容進行檢測,而getter 方法只是將內容簡單的返回。  
  24.    
  25.    
  26.    
  27.    
  28. class Person  
  29. {  
  30.        String name ;  
  31.        int age ;  
  32. };  
  33. // 要使用類需要通過對象  
  34. public class OODemo02  
  35. {  
  36.        public static void main(String args[])  
  37.        {  
  38.               // 格式:類 對象名 = new 類() ;  
  39.               // 聲明一個對象 lxh1  
  40.               // 在方法中聲明對象時必須賦值  
  41.               Person lxh1 = null ; //聲明,爲空。  
  42.               // 爲對象實例化,開闢堆內存空間  
  43.               lxh1 = new Person() ;  
  44.               lxh1.name = "李興華" ;  
  45.               lxh1.age = 28 ;  
  46.    
  47.               Person lxh2 = new Person() ;  
  48.    
  49.               lxh2 = lxh1 ;       // 對象的引用傳遞  
  50.    
  51.               lxh2.name = "魔樂先生" ;  
  52.               lxh1.age = 20 ;  
  53.    
  54.               // 試着輸出:  
  55.               System.out.println("姓名:"+lxh1.name) ;  
  56.               System.out.println("年齡:"+lxh1.age) ;  
  57.               System.out.println("*********************************") ;  
  58.               System.out.println("姓名:"+lxh2.name) ;  
  59.               System.out.println("年齡:"+lxh2.age) ;  
  60.        }  
  61. };  
  62.    
  63. 結果:  
  64. 姓名:魔樂先生  
  65. 年齡:20  
  66. ***********  
  67. 姓名:魔樂先生  
  68. 年齡:20  
  69.    
  70.    
  71. //定義格式; class 類名稱  
  72. //{}  
  73. class Person  
  74. {  
  75.        String name;  
  76.        int age;  
  77.        public void shout()  
  78.        {  
  79.               System.out.println("姓名:" + name);  
  80.               System.out.println("年齡:" + age);  
  81.        }  
  82. }  
  83. //要使用類需要通過對象  
  84.    
  85. public class javaoo012  
  86. {  
  87.        public static void main(String args[])  
  88.        {  
  89.               //格式;類 對象名 = new 類()  
  90.               //在方法中聲明對象時必須賦值  
  91.               Person hyj1= new Person();  
  92.               hyj1.name = "侯亞俊";  
  93.               hyj1.age = 22;  
  94.                
  95.               Person hyj2 = new Person();  
  96.               hyj2.name = "魔樂";  
  97.               hyj2.age = 20;  
  98.               //試着輸出  
  99.               hyj1.shout();  
  100.               System.out.println("***************************");  
  101.               hyj2.shout();  
  102.        }  
  103. }  
  104.    
  105. 姓名:侯亞俊  
  106. 年齡:22  
  107. ***************************  
  108. 姓名:魔樂  
  109. 年齡:20  
  110.    
  111.    
  112.    
  113. //類定義格式 :class 類名稱 標準的命名規範:首字母大寫  
  114. class Person  
  115. {  
  116.        String name;  
  117.        int age;  
  118.        public String shout()  
  119.        {  
  120.               this.run(); //run  
  121.               return "姓名;" + this.name + "/n年齡:" + this.age;  
  122.               //return  "姓名;" +name + "/n年齡:" + age;  
  123.        }  
  124. //this 如果沒有私有變量即體現不出其作用。  
  125.        public void run()  
  126.        {  
  127.               System.out.println("早上跑步。。。");  
  128.        }  
  129. }  
  130.    
  131. //要使用類需要通過對象  
  132. public class javaoo012  
  133. {  
  134.        public static void main(String args[])  
  135.        {  
  136.               //格式: 類 對象名 = new 類()  
  137.               //聲明一個對象hyj 在方法中聲明對象時必須賦值  
  138.               Person hyj1 = new Person();  
  139.               hyj1.name = "侯亞俊";  
  140.               hyj1.age = 22;  
  141.    
  142.               Person hyj2 = new Person();  
  143.               hyj2.name = "魔樂";  
  144.               hyj2.age = 20;  
  145.    
  146.               System.out.println(hyj1.shout());  
  147.               System.out.println("******************");  
  148.               System.out.println(hyj2.shout());  
  149.        }  
  150. }  
  151. 早上跑步。。。  
  152. 姓名;侯亞俊  
  153. 年齡:22  
  154. ******************  
  155. 早上跑步。。。  
  156. 姓名;魔樂  
  157. 年齡:20  
  158.    
  159. class Person  
  160. //無論採用那種方法爲類中的發生賦值,最好都經過setter 方法,由setter 方法對輸入的內//容進行檢測,而getter 方法只是將內容簡單的返回。  
  161.    
  162. class Person  
  163. {  
  164.        //private聲明的屬性只能在本類看見  
  165.        private String name;  
  166.        private int age;  
  167.        //加入一系列的setter 和 getter 方法  
  168.        public void setName(String n)  
  169.        {  
  170.               name = n;  
  171.        }  
  172.        public void setAge(int a )  
  173.        {  
  174.               if (a > 0 && a<150 )  
  175.               {  
  176.                      age = a;  
  177.               }  
  178.               else  
  179.               {  
  180.                      age = -1;  
  181.               }  
  182.        }  
  183.        public String getName()  
  184.        {  
  185.               return name;  
  186.        }  
  187.        public int getAge()  
  188.        {  
  189.               return age;  
  190.        }  
  191.        public String shout()  
  192.        {  
  193.               return "姓名:" + this.name + "/n年齡:" + this.age;  
  194.        }  
  195. }  
  196.    
  197. public class javaoo012  
  198. {  
  199.        public static void main(String args[])  
  200.        {  
  201.               Person hyj = new Person();  
  202.               hyj.setName("侯亞俊");  
  203.               hyj.setAge(22);  
  204.               System.out.println(hyj.shout());  
  205.        }  
  206. }  
  207.    
  208.    
  209.    
  210. //setter ,gettter沒明白什麼爲什麼要加判定邏輯錯誤???  
  211. class Person  
  212. {  
  213.        //private聲明的屬性只能在本類看見  
  214.        private String name;  
  215.        private int age;  
  216.    
  217.        public void setName(String n)  
  218.        {  
  219.               name = n;  
  220.        }  
  221.        public void setAge(int a )  
  222.        {  
  223.               if (a >0 && a <150)  
  224.               {  
  225.                      age = a;  
  226.               }  
  227.               else  
  228.               {  
  229.                      age = -1;  
  230.               }  
  231.        }  
  232.        public String getName()  
  233.        {  
  234.               return name;  
  235.        }  
  236.        public int getAge()  
  237.        {  
  238.               return age;  
  239.        }  
  240.        public String shout()  
  241.        {  
  242.               return "姓名:" + this.name + "/n年齡:" + this.age;  
  243.        }  
  244. }  
  245. //要使用類需要通過對象  
  246. public class javaoo012  
  247. {  
  248.        public static void main(String args[])  
  249.        {  
  250.               Person hyj = new Person();  
  251.               hyj.setName("侯亞俊");  
  252.               hyj.setAge(22);  
  253.               System.out.println(hyj.shout());  
  254.        }  
  255. }  
  256.    
  257. 姓名:侯亞俊  
  258. 年齡:22  
  259.    
  260.    
  261.    
  262.    
  263. //在java之中每個類必須有一個構造方法,如果沒有構造方法,則會自得生成一個無參的什麼都不做的構造方法,因爲所有的對象產生時都必須調用構造方法 如果程序中已經明確寫出了構造方法,則不會再產生一個無參的什麼都不做的構造方法。  
  264. //構造方法是在對象實例化時被自動調用 對象實例化需要通過new關鍵字  
  265. class Person  
  266. {  
  267.        //private 聲明的屬性只能在本類看見  
  268.        private String name;  
  269.        private int age;  
  270.        Person()  
  271.        {}  
  272.        //加入一個構造方法  
  273.        Person(String n,int a)  
  274.        {  
  275.               //爲類中的屬性初始化  
  276.               this.setName(n);  
  277.               this.setAge(a);  
  278.               System.out.println("******構造方法被調用******");  
  279.        }  
  280.    
  281.        //加入一系統的setter ,getter 方法  
  282.        public void setName(String n)  
  283.        {  
  284.               name = n;  
  285.        }  
  286.        public void setAge(int a)  
  287.        {  
  288.               if (a > 0 && a < 150)  
  289.               {  
  290.                      age = a;  
  291.               }  
  292.               else  
  293.               {  
  294.                      age = -1;  
  295.               }  
  296.        }  
  297.        public String getName()  
  298.        {  
  299.               return name;  
  300.        }  
  301.        public int getAge()  
  302.        {  
  303.               return age;  
  304.        }  
  305.    
  306.        public String shout()  
  307.        {  
  308.               return "姓名:" + this.name + "/n年齡:" + this.age;  
  309.        }  
  310. }  
  311.    
  312. public class javaoo012  
  313. {  
  314.        public static void main(String args[])  
  315.        {  
  316.               Person hyj = new Person("李興華",-22);  
  317.               Person hyj1 = new Person();  
  318.               hyj1.setName("侯亞俊");  
  319.               hyj1.setAge(22);  
  320.               System.out.println(hyj.shout());  
  321.               System.out.println("************");  
  322.               System.out.println(hyj1.shout());  
  323.        }  
  324. }  
  325.    
  326.    
  327. ******構造方法被調用******  
  328. 姓名:李興華  
  329. 年齡:-1  
  330. ************  
  331. 姓名:侯亞俊  
  332. 年齡:22  
  333.    

 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章