面向对象基础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.    

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值