原Java学习笔记014 - 面向对象

Posted iflytek

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了原Java学习笔记014 - 面向对象相关的知识,希望对你有一定的参考价值。

 1 package cn.temptation;
 2 
 3 public class Sample01 {
 4     public static void main(String[] args) {
 5         // 面向对象思想
 6         
 7         // 回顾编程语言思想进化之路:从面向过程到面向对象
 8         
 9         // 面向过程
10         // 举例:
11         // 1、冰箱门打开
12         // 2、大象放进去
13         // 3、冰箱门关上
14         // 【面向过程的思路的着眼点在于动作的功能,思考打开、放入、关闭均为动作】
15         
16         // 面向对象:随着软件工程的成熟,人们根据自然的、正常的思考逻辑,从概念模型入手,考虑其特征及行为
17         // 举例:
18         // 比如:买手机,首先考虑的是有一个手机的概念模型,其特征(便携性、美观性等)及行为(打电话、发短信、上网等)迎合人们的一些方面的需要
19         // 再去思考面向过程的放大象的这个例子
20         // 为什么我们会想到打开冰箱门?因为冰箱在我们的头脑中已经形成了一个概念模型,我们知道它有一个特征(门),并且还有其行为(可以打开和关闭)
21         // 为什么我们会想到大象可以放入冰箱中?因为冰箱给我们另一个特征(是一个大容器,换句话说就是其有容量)
22         // 所以,我们人类的思考点还是自然而然的聚焦到概念模型上
23         // 【面向对象的思路的着眼点在于概念模型的特征及行为】
24         
25         // 对象:大千世界中的万物都是对象
26         // 关注对象,主要关注对象的两个方面:特征   和    行为
27         // 举例:在淘宝上买衣服,关注衣服的外形、颜色、价格等等(特征),还要关注衣服的行为(是不是穿上衣服大家点赞等)
28         
29         // 面向对象的思考中,不但要考虑单个对象的特征和行为,而且要考虑对象和对象之间的关联关系
30         // 举例:买一个手机,关注这个手机的各种参数(特征),还有手机的功能(打电话、上网等)(行为)
31         //        除此之外,手机能使用,还得需要手机卡,手机卡是另一个对象,手机和手机卡之间有关联关系的(比如:只支持电信的手机就不能使用移动的卡)
32         
33         // 对象的特征:表征对象特点的描述,在Java中称为属性
34         // 对象的行为:表征对象实现功能的途径,在Java中称为方法
35         
36         // 类:(成语:物以类聚)
37         // 定义:在面向对象思想中,类是具有相同的属性 和 行为 的一系列物体的集合,具有抽象意味
38         
39         // 举例:学生类
40         // 属性:学号、年龄、性别、姓名...
41         // 行为:读书、考试、吃饭、睡觉...
42         
43         // 对象:
44         // 定义:是类的具体表现形式,具体化的、实实在在的物体
45         
46         // 举例:张三    是个 学生(对象),他 是学生类的具体化的产物
47     }
48 }
 1 package cn.temptation;
 2 
 3 public class Sample02 {
 4     public static void main(String[] args) {
 5         /*
 6          * 类的形式
 7          * 
 8          * 修饰符             class     类名 {
 9          *      成员变量;
10          *      成员方法;
11          * }
12          * 
13          * 成员变量用来记录属性(特征)
14          * 成员方法用来记录行为(动作)
15          * 
16          * 仅仅有一个类,只是有了一个模板,要具体的使用,还需要有对象
17          * 依据类这个模板创建具体对象实例的方式或者过程,称为类的实例化,也就是说类的实例化得到的是具体的对象
18          * 
19          * 类   是  什么类型的?    类类型  是  一种类型,也是一种引用数据类型
20          * 引用数据类型的存储特点:声明在栈上,具体的内容通过new关键字存储在堆中开辟的空间里
21          * 
22          * 类的实例化的格式:
23          * 类名     对象名      =    new    类名();
24          * 
25          * 如何来使用类这个模板中定义了的成员变量 和  成员方法?
26          * 借助于   点号运算符 .
27          * 使用成员变量  对象名.成员变量
28          * 使用成员方法  对象名.成员方法
29          */
30         
31         // 类的实例化,得到一个具体的对象
32         Student student = new Student();
33         System.out.println(student);            // [email protected]
34         
35         // 基本数据类型(值类型)的默认值
36         // byte、short、int、long:0
37         // float、double:0.0
38         // char:‘\u0000‘
39         // boolean:false
40         
41         // 引用数据类型的默认值:null
42         
43         // 成员变量的使用(取值)
44         System.out.println(student.studentNumber);        // 0
45         System.out.println(student.studentName);            // null
46         System.out.println(student.age);                    // 0
47         System.out.println(student.gender);                // null
48         
49         // 针对成员变量的赋值
50         student.studentNumber = 7;
51         student.studentName = "张三";
52         student.age = 18;
53         student.gender = "男";
54         
55         // 成员变量的使用(取值)
56         System.out.println(student.studentNumber);        // 7
57         System.out.println(student.studentName);            // 钱博文
58         System.out.println(student.age);                    // 18
59         System.out.println(student.gender);                //60         
61         // 成员方法的使用
62         student.study();
63         student.eat();
64         student.say("我是钱博文,我喂自己袋盐!");
65     }
66 }
67 
68 // 类的定义:创建一个学生类
69 class Student {
70     // 成员变量
71     // 学号
72     int studentNumber;
73     // 姓名
74     String studentName;
75     // 年龄
76     int age;
77     // 性别
78     String gender;
79     
80     // 成员方法
81     // 学习方法
82     public void study() {
83         System.out.println("书中自有颜如玉!");
84     }
85     
86     // 吃饭方法
87     public void eat() {
88         System.out.println("民以食为天!");
89     }
90     
91     // 说话方法
92     public void say(String word) {
93         System.out.println("说:" + word);
94     }
95 }
 1 package cn.temptation;
 2 
 3 public class Sample03 {
 4     public static void main(String[] args) {
 5         // 类的实例化
 6         
 7         // 类作为模板,自然可以创建出多个该类类型的对象
 8         Dog dog1 = new Dog();
 9         System.out.println(dog1);        // [email protected]
10         
11         Dog dog2 = new Dog();
12         System.out.println(dog2);        // [email protected]
13         
14         // new关键字使用一次,就在内存的堆中开辟一块空间
15     }
16 }
17 
18 // 定义狗类
19 class Dog {
20     // 成员变量
21     int id;
22     String name;
23     int age;
24     
25     // 成员方法
26     
27 }
 1 package cn.temptation;
 2 
 3 public class Sample04 {
 4     public static void main(String[] args) {
 5         // 需求:创建一个手机类,其特征为品牌(brand)、价格(price)、颜色(color);其行为有打电话、发短信
 6         
 7         // 类的实例化
 8         Phone phone = new Phone();
 9         phone.brand = "HUAWEI";
10         phone.price = 1000;
11         phone.color = "黑色";
12         
13         System.out.println("手机的品牌为:" + phone.brand + ",价格为:" + phone.price + ",颜色为:" + phone.color);
14         
15         phone.call("110");
16         phone.sendMsg("120", "快回来吃饭!!");
17     }
18 }
19 
20 // 定义手机类
21 class Phone {
22     // 成员变量
23     // 品牌
24     String brand;
25     // 价格
26     int price;
27     // 颜色
28     String color;
29     
30     // 成员方法
31     // 打电话
32     public void call(String number) {
33         System.out.println("打电话给:" + number);
34     }
35     
36     // 发短信
37     public void sendMsg(String number, String msg) {
38         System.out.println("发短信给:" + number + ",内容为:" + msg);
39     }
40 }
 1 package cn.temptation;
 2 
 3 public class Sample05 {
 4     public static void main(String[] args) {
 5         // 成员变量  和  局部变量
 6         
 7         Test test = new Test();
 8         
 9 //        System.out.println("成员变量i:" + test.i);
10         // 对于只声明不赋值的成员变量,使用时使用的是它的默认值
11         
12 //        test.show1();
13         test.show2(4);
14         test.show3();
15     }
16 }
17 
18 // 定义一个测试类
19 class Test {
20     // 成员变量
21 //    int i;        // 成员变量只做声明不做赋值,语法上OK
22     int i = 2;    // 成员变量声明时同时进行赋值,语法上OK
23     // 在成员变量中也声明并赋值一个变量j
24     int j = 3;
25     
26     // 成员方法
27     public void show1() {
28 //        System.out.println(i);        // 在成员方法中访问成员变量i,是可以访问的
29 
30         // 语法错误:j cannot be resolved to a variable  不声明就直接使用变量j,是无法使用的
31 //        System.out.println(j);
32         
33         // 在方法中声明并赋值了变量j,这里的j是什么变量?            答:局部变量
34         int j = 5;
35         // 语法错误:The local variable j may not have been initialized        只声明不赋值,提示未初始化
36 //        int j;
37         System.out.println("方法内的变量j:" + j);
38     }
39     
40     public void show2(int j) {
41         System.out.println("方法内的变量j:" + j);    // 变量j写在方法的形参位置,它既是形参,也是局部变量
42         // 局部变量的作用域(作用范围)就是从其变量声明的地方开始,到其所在方法的右侧大括号结束
43     }
44     
45     public void show3() {
46         // 当前方法中没有该变量名的局部变量的声明,同时又没有该变量名的成员变量的声明,直接使用该变量名,有语法错误
47         // 语法错误:j cannot be resolved to a variable  不声明就直接使用变量j,是无法使用的
48         // 当前方法中没有该变量名的局部变量的声明,同时有该变量名的成员变量的声明,直接使用该变量名,没有语法错误
49         System.out.println(j);
50         // 这里直接使用了作为成员变量j的值,也就是说在方法中,如果没有同名的局部变量j,使用变量j时,就会到成员变量中找是否有j
51         
52         // 疑问:
53         // 1、show3方法中没有定义j变量,为何没有去上面的方法show1 和 show2中去找?
54         // 答:从局部变量的作用域来看,局部变量只能在其所在方法中使用的,超出了这个范围就无法使用了
55         // 2、Test类中有成员变量j,show1方法 和 show2方法中又有局部变量j,调用方法时,为何显示的还是局部变量j的值?
56         // 答:变量的调用原则:就近原则
57     }
58 }
59 /*
60  * 成员变量    和    局部变量的区别:
61  * 1、代码位置上的区别:
62  * A、局部变量:在方法中或是在方法的形参中定义的
63  * B、成员变量:在类中且在方法外定义的
64  * 
65  * 2、内存中位置的区别:
66  * A、局部变量:存储在栈上(方法调用时,会将方法压入栈中;方法调用结束后,会将方法从栈中弹出)
67  * B、成员变量:存储在堆中
68  * 
69  * 3、生命周期上的区别:
70  * A、局部变量:跟着方法来的,方法被调用,方法被压入栈中,局部变量产生了;方法调用结束后,方法从栈中弹出,局部变量也就销毁了
71  * B、成员变量:随着对象的创建而创建,随着对象的消亡而消亡
72  * 
73  * 4、初始值上的区别:
74  * A、局部变量:需要被初始化才可以使用,换句话说就是没有默认值
75  * B、成员变量:有默认值,可以不用初始化就拿着默认值使用
76  */

 

以上是关于原Java学习笔记014 - 面向对象的主要内容,如果未能解决你的问题,请参考以下文章

原Java学习笔记019 - 面向对象

原Java学习笔记017 - 面向对象

原Java学习笔记026 - 集合

从0开始的Python学习014面向对象编程

Java学习笔记

Java千百问_05面向对象(014)_如何获取范型的类Class