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("
**访问对象的属性和行为");
 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("
**范例：统计图书销量");
 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("
**汉诺塔方法，难难难！！没继续研究下去！");
 44               int nDisks=3;
 45               moveDish(nDisks,'A','B','C');
 46               
 47               //单例模式：皇帝
 48               //Emperor ep=new Emperor(); 构造方法不允许访问的
 49               System.out.println("
**单例模式");
 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("
");
 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;
        }
    }