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
实战例子：
1 import java.util.StringTokenizer; 2 3 public class HelloTest { 4 5 public static void main(String[] args) { 6 // TODO Auto-generated method stub 7 // 继承类时，可以获取该类的成员变量的值 8 Desktop desktop = new Desktop(); 9 desktop.setType("ThinkPad"); 10 String dsType = desktop.getType(); 11 System.out.println(dsType); 12 13 // 矩形类，长宽作为类的属性，在构造方法中将长宽初始化，定义一个成员方法求矩形面积 14 Juxing jx = new Juxing(8.5, 7); 15 double w = jx.getWidth(); 16 double h = jx.getHeight(); 17 // double area=jx.area(w, h); //方法一 18 double area = jx.area(); 19 System.out.println("长方形的面积是：" + area); 20 21 } 22 23 } 24 25 class Desktop { 26 private String type; 27 private String sys; 28 private int size; 29 30 public Desktop() { 31 } 32 33 public void setType(String type) { 34 this.type = type; 35 } 36 37 public String getType() { 38 return this.type; 39 } 40 41 } 42 43 class Juxing { 44 45 private double width; 46 private double height; 47 48 public Juxing() { 49 // 构造方法 50 } 51 52 public Juxing(double width, double height) { 53 this.width = width; 54 this.height = height; 55 } 56 57 public double getWidth() { 58 return this.width; 59 } 60 61 public double getHeight() { 62 return this.height; 63 } 64 65 /********** 66 * 方法一 67 * public double area(double width,double heigth){ 68 * double area=width*height; 69 * return area; 70 * } 71 *****************/ 72 public double area() { 73 return this.height * this.width; 74 } 75 }
