No1_8.类和对象2_Java学习笔记_对象

对象

        /****
         * *一、对象
            *1.概念：对象是由类抽象出来的，对象可以操作类的属性和方法解决问题，了解对象的创建、操作和消亡很必要；
            *2.对象的创建：
            *    a.    new操作符创建；每实例化一个对象就会自动调用一次构造方法；
            *    即：在Java语方中使用new操作调用构造方法创建对象；
            *    b.Test[类] test[类对象]=new[操作符]  Test("a"[构造方法的参数]);
            *    c.对象创建时，在内存中为对象分配内存空间，初始化成员变量；
            *    d.每个对象都是相互独立的，在内存中占用独立的内存地址，有自己的生命周期，周期结束对象变成垃圾，虚拟机自动回收；
            *3.访问对象的属性和行为：
            *    a.对象.类成员 获取；
            *    b.如果希望成员变量随其中任何一个对象改变，用static关键字；（一个static的成员变量的值可以被本类或其它类的对象共享）
            *4.对象的引用
            *    a.语法格式：类名对象引用名称  Book book
            *    b.通常一个引用不一定需要有一个对象相关联，引用与对象相关联的语法： Book book=new Book();
            *    c.引用只是存放一个对象的内存地址，并非存放一个对象；
            *5.对象的比较
            *    a.两种比较方式 ，“==”与 equals() 方法
            *    b.区别：equals()方法比较两对象引用所指的内容是否相等；==比较的是两对象引用的地址是否相等；
            *6.对象的销毁
            *    a.每个对象都有生命周期，当对象的生命周期结束时，分配给对象的内存地址将会被回收；
            *    b.Java拥有垃圾回收机制，用户不用担心对象占用内存；
            *    c.两种情况会被Java虚拟机视为垃圾；
            *        @对象引用超过其作用范围；
            *        @将对象赋值为null；
            *    d.垃圾回收只能回收那些由new操作符创建的对象；非new创建的，在内存获取的内存区域，不被识别；
            *    e.finalize()方法，是Object类的protected方法，垃圾回收时首先调用该方法，下一次垃圾回收动作发生时，才回收对象占用的内存。
            *    f.垃圾回收或是finalize()方法不保证一定会发生，虚拟机面临内存损耗待尽的形况，不执行垃圾回收；
            *    g.垃圾回收执行时间不确定，finalize()方法也就无法执行，为此Java提供了System.gc()方法强制启动垃圾回收器；
            *7.单例模式
            *    a.所谓单例模式就是一个类有且只有一个实例；独一无二~
         */
        

练习：

  1 import java.util.Random;
  2
  3 public class HelloClassObject2 {
  4     static int i=77;    //类的成员变量 如果变量i声明成static类型，可以被本类或其它类的对象共享，会跟着变
  5
  6     public static void main(String[] args) {
  7         // TODO Auto-generated method stub
  8             //对象的创建
  9             System.out.println("**对象的创建");
 10             new HelloClassObject2();
 11             HelloClassObject2 co1 =new HelloClassObject2();
 12             HelloClassObject2 co2=new HelloClassObject2();
 13             System.out.println("比较对象内存地址(co1==co2)："+(co1==co2));
 14
 15             //访问对象的属性和行为
 16             System.out.println("\n**访问对象的属性和行为");
 17             co2.i=60;
 18             //使用第一个对象调用类成员变量
 19             System.out.println("第一个实例对象调用变量i的结果："+co1.i++);
 20             co1.call();
 21             //使用第二个对象调用类成员变量
 22             System.out.println("第二个实例对象调用变量i的结果："+co2.i);
 23             co2.call();
 24
 25             //对象的比较
 26             //equals()方法比较两对象引用所指的内容是否相等；==比较的是两对象引用的地址是否相等
 27             System.out.println("**对象的比较");
 28             String s1=new String("abc");
 29             String s2=new String("abc");
 30             String s3=s1;
 31             System.out.println("s1==s3的运算结果为："+(s2==s3));
 32             System.out.println("s2.equals(s3)的运算结果为："+s2.equals(s3));
 33
 34             //范例：统计图书销量
 35             System.out.println("\n**范例：统计图书销量");
 36             String[] titles={"《幻城》","《1988我想和这个世界谈谈》","《那小子真帅》"};
 37             for( int i=0;i<5;i++){
 38                 new Book(titles[new Random().nextInt(3)]);
 39             }
 40               System.out.println("总计销售了"+Book.getCount()+"本书！");
 41
 42               //经典：汉诺塔问题求解
 43               System.out.println("\n**汉诺塔方法，难难难！！没继续研究下去！");
 44               int nDisks=3;
 45               moveDish(nDisks,'A','B','C');
 46
 47               //单例模式：皇帝
 48               //Emperor ep=new Emperor(); 构造方法不允许访问的
 49               System.out.println("\n**单例模式");
 50               Emperor hd=Emperor.getInstance();
 51               Emperor hd2=Emperor.getInstance();
 52               hd.getName();
 53               System.out.println("比较对象内容hd.equals(hd2)："+hd.equals(hd2));    //对象内容
 54               System.out.println("比较对象内存地址(hd==hd2)："+(hd==hd2));            //存储地址
 55     }
 56
 57                 //构造方法
 58                 public HelloClassObject2(){
 59                     System.out.println("构造方法自动调用");
 60                 }
 61
 62                 //call方法
 63                 public void call(){
 64                     System.out.println("调用call()方法");
 65                     for(i=0;i<3;i++){                //如果int i=0 的话，与类成员变量i就不是同一个变量了
 66                         System.out.print(i+" ");
 67                         if(i==2){
 68                             System.out.println("\n");
 69                         }
 70                     }
 71                 }
 72                 //call方法结束
 73
 74                 //汉诺塔方法，利用递规方法调用 ~~~~其实不是不太懂啦，有时间了再琢磨吧~~~~~
 75                 public static void moveDish(int level,char from,char inter, char to){
 76
 77                     if(level==1){
 78                         System.out.println("从"+from+"移动盘子1号到"+to);
 79                     } else {
 80                         moveDish(level-1, from, to, inter );
 81                         System.out.println("从"+from+"移动盘子"+level+"号到"+to);
 82                         moveDish(level-1, inter, from,  to);
 83                     }
 84                 }
 85 }//类结束~~
 86
 87                 //范例：统计图书销量
 88                 class Book{
 89                     private static  int count =0;        //定义计数器，如果变量声明成static类型，可以被本类或其它类的对象共享，会跟着变
 90                     public Book(String title){
 91                         //构造方法
 92                         System.out.println("售出图书："+title);
 93                         count++;
 94                     }
 95                     public static int getCount(){
 96                         return count;
 97                     }
 98                 }
 99
100                 //单例模式的应用：所谓单例模式就是一个类有且只有一个实例
101                 class Emperor{
102                      static Emperor emperor=null;    //声明一个Emperor类的引用
103                     private Emperor(){ //私有构造函数，防止外部new一个新实例
104                         //构造方法
105                     };
106
107                     public static Emperor getInstance(){
108                         if(emperor==null){
109                             emperor=new Emperor();
110                         }
111                         return emperor;
112                     }
113                     public  void getName(){
114                         System.out.println("皇帝只有一个，皇帝类只能实例化一个人！！");
115                     }
116                 }
117     

输出结果：

 1 **对象的创建
 2 构造方法自动调用
 3 构造方法自动调用
 4 构造方法自动调用
 5 比较对象内存地址(co1==co2)：false
 6
 7 **访问对象的属性和行为
 8 第一个实例对象调用变量i的结果：60
 9 调用call()方法
10 0 1 2
11
12 第二个实例对象调用变量i的结果：3
13 调用call()方法
14 0 1 2
15
16 **对象的比较
17 s1==s3的运算结果为：false
18 s2.equals(s3)的运算结果为：true
19
20 **范例：统计图书销量
21 售出图书：《幻城》
22 售出图书：《1988我想和这个世界谈谈》
23 售出图书：《幻城》
24 售出图书：《那小子真帅》
25 售出图书：《1988我想和这个世界谈谈》
26 总计销售了5本书！
27
28 **汉诺塔方法，难难难！！没继续研究下去！
29 从A移动盘子1号到C
30 从A移动盘子2号到B
31 从C移动盘子1号到B
32 从A移动盘子3号到C
33 从B移动盘子1号到A
34 从B移动盘子2号到C
35 从A移动盘子1号到C
36
37 **单例模式
38 皇帝只有一个，皇帝类只能实例化一个人！！
39 比较对象内容hd.equals(hd2)：true
40 比较对象内存地址(hd==hd2)：true

实战例子：

 import java.util.StringTokenizer;

 public class HelloTest {

     public static void main(String[] args) {
         // TODO Auto-generated method stub
         // 继承类时，可以获取该类的成员变量的值
         Desktop desktop = new Desktop();
         desktop.setType("ThinkPad");
         String dsType = desktop.getType();
         System.out.println(dsType);

         // 矩形类，长宽作为类的属性，在构造方法中将长宽初始化，定义一个成员方法求矩形面积
         Juxing jx = new Juxing(8.5, 7);
         double w = jx.getWidth();
         double h = jx.getHeight();
         // double area=jx.area(w, h); //方法一
         double area = jx.area();
         System.out.println("长方形的面积是：" + area);

     }

 }

         class Desktop {
             private String type;
             private String sys;
             private int size;

             public Desktop() {
             }

             public void setType(String type) {
                 this.type = type;
             }

             public String getType() {
                 return this.type;
             }

         }

     class Juxing {

         private double width;
         private double height;

         public Juxing() {
             // 构造方法
         }

         public Juxing(double width, double height) {
             this.width = width;
             this.height = height;
         }

         public double getWidth() {
             return this.width;
         }

         public double getHeight() {
             return this.height;
         }

         /**********
          * 方法一
          * public double area(double width,double heigth){
          *  double area=width*height;
          *  return area;
          *   }
          *****************/
         public double area() {
             return this.height * this.width;
         }
     }