新手初学Java面向对象

java面向对象

1. 面向对象【Java语言的核心机制，最重要的内容，Java语言的特色】
2. * 面向过程和面向对象的区别
3. - 面向过程：主要关注点是：实现的具体过程，因果关系【集成显卡的开发思路】
4. * 优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。
5. * 缺点：采用面向过程的方式开发很难解决非常复杂的业务逻辑，另外面向过程的
6. 方式导致软件元素之间的“耦合度”非常高，只要其中一环出问题，整个系统受到影响，
7. 导致最终的软件“扩展力”差。另外，由于没有独立体的概念，所以无法达到组件复用。
8. - 面向对象：主要关注点是：主要关注对象【独立体】能完成哪些功能。【独立显卡的开发思路】
9. * 优点：耦合度低，扩展力强。更容易解决现实世界当中更复杂的业务逻辑。组件复用性强。
10. * 缺点：前期投入成本较高，需要进行独立体的抽取，大量的系统分析与设计。
11. - C语言是纯面向过程的、C++半面向对象、Java纯面向对象
12. - 现在出现的一些新的编程语言多数都是面向对象的。人在认识现实世界的时候以面向对象的方式。
13. - 面向对象更符合人的思维方式。
14. * 面向对象的三大特征【先背会】
15. - 封装
16. - 继承
17. - 多态
18. 所有面向对象的编程语言都有这三大特征。
19. 采用面向对象的方式开发一个软件，生命周期当中：【整个生命周期中贯穿使用OO面向对象方式】
20. * 面向对象的分析：OOA
21. * 面向对象的设计：OOD
22. * 面向对象的编程：OOP
23. * 类和对象的概念
24. * 什么是类？
25. - 类在现实世界当中是不存在的，是一个模板，是一个概念。是人类大脑思考抽象的结果。
26. - 类代表了一类事物。
27. - 在现实世界当中，对象A与对象B之间具有共同特征，进行抽象总结出一个模板，这个模板被称为类。
28. * 什么是对象？
29. - 对象是实际存在的个体。现实世界当中实际存在。
30. * 描述一下整个软件开发的过程：
31. * 程序员先观察现实世界，从现实世界当中寻找对象
32. * 寻找了N多个对象之后，发现所有的对象都有共同特征
33. * 程序员在大脑中形成了一个模板【类】
34. * Java程序员可以通过java代码来表述一个类
35. * Java程序中有了类的定义
36. * 然后通过类就可以创建对象
37. * 有了对象之后，可以让对象直接协作起来形成一个系统。
38. * 类--【实例化】->对象
39. * 对象又被称为实例/instance
40. * 对象--【抽象】-->类
41. * 重点：
42. 类描述的是对象的共同特征。
43. 共同特征例如：身高特征
44. 这个身高特征在访问的时候，必须先创建对象，通过对象去访问这个特征。
45. 因为这个特征具体的某个对象上之后，值不同。有的对象身高1.80，有的
46. 对象身高2.80。
47. * 一个类主要描述什么信息呢？
48. 一个类主要描述的是 状态 + 动作。
49. 状态信息：名字、身高、性别、年龄
50. 动作信息：吃、唱歌、跳舞、学习
51. 状态--> 一个类的属性
52. 动作--> 一个类的方法
53. *
54. 类{
55. 属性; //描述对象的状态信息
56. 方法; //描述对象的动作信息
57. }
58. 注意：
59. 状态和动作当具体到某个对象上之后，发现最终的结果可能不一样。
60. 对象和对象之间有共同特征，但是具体到对象之后有数据的差异。
61. * 类的定义【从这里开始编写代码】
62. 语法结构：
63. [修饰符列表] class 类名{
64. 属性;
65. 方法;
66. }
67. 学生类，描述所有学生对象的共同特征：
68. 学生对象有哪些状态信息：
69. * 学号【int】
70. * 名字【String】
71. * 性别【boolean】
72. * 年龄【int】【年龄是一个属性，年龄是一个数据，是数据就应该有数据类型】
73. * 住址【String】
74. .....
75. 学生对象有哪些动作信息：
76. * 吃饭
77. * 睡觉
78. * 学习
79. * 玩
80. * 唱歌
81. * 跳舞
82. ....
83. 重点：属性通常是采用一个变量的形式来完成定义的。
84. int no;
85. int age;
86. String name;
87. String address;
88. boolean sex;
89. * java语言中包括两种数据类型：
90. - 基本数据类型
91. byte
92. short
93. int
94. long
95. float
96. double
97. boolean
98. char
99. - 引用数据类型
100. String.class SUN提供的
101. System.class SUN提供的
102. Student.class 程序员自定义的
103. User.class 程序员自定义的
104. Product.class 程序员自定义的
105. Customer.class 程序员自定义的
106. ......
107. - java语言中所有的class都属于引用数据类型。

1. // 定义一个类，类名Student
2. // Student是一个类，代表了所有的学生对象，是一个学生的模板。
3. public class Student{ // 定义一个公开的类，起名Student
4. // 属性【描述的是对象的状态信息】
5. // 熟悉通常采用变量的方式来定义
6. // 在类体当中，方法体之外定义的变量被称为“成员变量”
7. // 成员变量没有赋值，系统赋默认值：一切箱0看齐。
8. // 学号
9. int no;
10. // 姓名
11. String name;
12. // 性别
13. boolean sex;
14. // 年龄
15. int age;
16. // 住址
17. String address;
18. // 方法
19. // 方法描述的是对象的动作信息
20. // 当前例子就只描述属性了
21. }

1. // 学生类
2. // 学生类是一个模板
3. // 描述了所有学生的共同特征【状态+行为】
4. // 当前类只描述学生的状态信息【属性】
5. // Student是类，属于引用数据类型，这个类型名就是：Student
6. public class Student{
7. // 类体-属性+方法
8. // 属性【存储数据采用变量的形式】
9. // 由于变量定义在类体当中，方法体之外，这种变量称为成员变量
10. // 所有学生都有学好信息
11. // 但是每一个学生的学号都是不同的
12. // 所以要访问这个学号必须先创建对象，通过对象去访问学号信息
13. // 学号信息不能直接通过“类”去访问，所以这种成员变量又被叫做：实例变量
14. // 对象又被称为实例，实例变量又成为对象变量。【对象级别的变量】
15. // 不创建对象，这个no变量的内存空间是不存在的，只有创建了对象，这个no变量内存空间才会创建
16. int no;
17. // 姓名
18. String name;
19. // 年龄
20. int age;
21. // 性别
22. boolean sex;
23. // 住址
24. String addr;
25.  
26. }
27. // 成员变量没有手动赋值的话，系统赋默认值
28. // 默认值
29. /*
30. 数据类型 默认值
31. ---------------------------------
32. byte，short，int，long 0
33. float，double 0.0
34. boolean false
35. char \u0000
36. 引用数据类型 null 空值
37. */
38. // -----------------------------------------------------------------------------------------------------
39. /*
40. 对象的创建和使用
41. */
42. public class OOTest01
43. {
44. public static void main(String[] args){
45. // int 是基本数据类型
46. // i 是一个变量名
47. // 10是一个int类型的字面值
48. int i = 10;
49. // 通过一个类可以实例化N个对象
50. // 实例化对象的语法：new 类名();
51. // new是java语言当中的一个运算符
52. // new运算符的作用是创建对象，在JVM堆内存当中开辟新的内存空间
53. // 方法区内存：在类加载的时候，class字节码片段被加载到该内存空间当中
54. // 栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈
55. // 堆内存：new的对象在堆内存中存储
56. // Student是一个应用数据类型
57. // s 是一个变量名
58. // new Student()是一个学生对象
59. // s是一个局部变量【在栈内存中存储】
60. // 什么是对象？new运算符在堆内存中开辟的内存空间称为对象
61. // 什么是引用？引用是一个变量，只不过这个变量保存了另一个java对象的内存地址
62. // java语言当中，程序员不能直接操作堆内存，java中没有指针，不像c语言
63. // java语言当中，程序员只能通过“引用”去访问堆内存当中对象内部的示例变量
64. Student s = new Student();
65. // 访问实例变量的语法格式：
66. // 读取数据：引用.变量名
67. // 修改数据：引用.变量名 = 值
68. /*
69. int stuNo = s.no;
70. String stuName = s.name;
71. int stuAge = s.age;
72. boolean stuSex = s.sex;
73. String stuAddr = s.addr;
74. System.out.println("学号 = " + stuNo);
75. System.out.println("姓名 = " + stuName);
76. System.out.println("年龄 = " + stuAge);
77. System.out.println("性别 = " + stuSex);
78. System.out.println("地址 = " + stuAddr);
79. */
80. s.no = 10;
81. s.name = "jack";
82. s.age = 20;
83. s.sex = true;
84. s.addr = "深圳";
85. System.out.println("学号 = " + s.no); // 10
86. System.out.println("姓名 = " + s.name); // jack
87. System.out.println("年龄 = " + s.age); // 20
88. System.out.println("性别 = " + s.sex); // true
89. System.out.println("地址 = " + s.addr); // 深圳
90. // 编译报错，no这个实例变量不能直接采用”类名“的方式访问
91. // 因为no是实例变量，对象级别的变量，变量存储在java对象的内部，必须先有对象
92. // 通过对象才能访问no这个实例变量，不能直接通过"类名"访问
93. // System.out.println(Student.no);
94. // 在通过类实例化一个全新的对象
95. // stu是一个引用类型
96. // stu同时也是一个局部变量
97. // Student是变量的数据类型
98. Student stu = new Student();
99. System.out.println("学号 = " + stu.no); // 0
100. System.out.println("姓名 = " + stu.name); // null
101. System.out.println("年龄 = " + stu.age); // false
102. System.out.println("性别 = " + stu.sex); // 0
103. System.out.println("地址 = " + stu.addr); // null
104. }
105. }
106.  
107. /*
108. 局部变量在栈内存中存储
109. 成员变量中的实例变量在堆内存的java对象内存存储
110. 实例变量是一个对象一份，100个对象有100份。
111. */

1. // 用户类
2. public class User{
3. // 属性【以下都是成员变量之实例变量】
4. // 用户编号
5. // int 是一种基本数据类型：整数型
6. // no是一个实例变量
7. int no;
8. // 用户名
9. // String 是一种引用数据类型：代表字符串
10. // name是一个实例变量
11. // name是一个引用
12. String name;
13. // 家庭住址
14. // Adddress是一种引用数据类型：代表家庭住址
15. // addr是一个实例变量
16. // addr是一个引用
17. Address addr;
18. }
19. // ----------------------------------------------------------------------
20. // 家庭住址类
21. public class Address{
22. // 属性成员变量之实例变量】
23. // 城市
24. // String是一种引用数据类型，city是一个变量名，属于实例变量
25. // oity是一个引用：保存内存地址的一个变量，该变量保存内存地址指向了堆内存当中的对象
26. String city;
27. // 街道
28. String street;
29. // 邮编
30. String zipcode;
31. }
32. // ----------------------------------------------------------------------
33. // 测试类
34. public class OOTest02{
35. public static void main(String[] args){
36. // 创建User对象
37. // u是局部变量
38. // u是一个应用
39. // u保存内存地址指向堆内存的User对象
40. User u = new User();
41. // 输出User对象内部实例变量的值
42. System.out.println(u.no); // 0
43. System.out.println(u.name); // null
44. System.out.println(u.addr); // null
45. // 修改User对象内部实例变量的值
46. u.no = 110;
47. u.name = "jack"; // "jack" 是一个java对象，属于String对象
48. u.addr = new Address();
49. // 在main方法当中目前只能看到一个引用“u”
50. // 一切都是只能通过u来进行访问
51. System.out.println(u.name + "居住在那个城市:" + u.addr.oity);
52. System.out.println(u.name + "居住在那个街道:" + u.addr.street);
53. System.out.println(u.name + "居住在那个邮编:" + u.addr.zipcode);
54. u.addr.oity = "深圳";
55. u.addr.street = "福田";
56. u.addr.zipcode = "516600";
57. System.out.println(u.name + "居住在那个城市:" + u.addr.oity);
58. System.out.println(u.name + "居住在那个街道:" + u.addr.street);
59. System.out.println(u.name + "居住在那个邮编:" + u.addr.zipcode);
60.  
61. }
62. }

1. public class OOTest03{
2. public static void main(String[] args){
3. // u是引用
4. // u是局部变量
5. User u = new User();
6. // 上一个版本中编写的
7. // u.addr = new Address();
8. // a是引用
9. // a是局部变量
10. Address a = new Address();
11. u.addr = a;
12.  
13. System.out.println(u.addr.city); // null
14. a.city = "天津";
15. System.out.println(u.addr.city); // 天津
16. u.addr.city = "深圳";
17. System.out.println(u.addr.city); // 深圳
18. }
19. }

1. // 丈夫类
2. public class Husband{
3. // 姓名
4. String name;
5. // 丈夫对象当中含有妻子引用
6. Wife w;
7. }
8. // -----------------------------------------------------------------
9.  
10. // 妻子类
11. public class Wife{
12. // 姓名
13. String name;
14. // 妻子对象当中含有丈夫引用
15. Husband h;
16. }
17. // -------------------------------------------------------------------
18. public class OOTest04{
19. public static void main(String[] args){
20. // 创建一个丈夫对象
21. Husband huangXiaoMing = new Husband();
22. huangXiaoMing.name = "黄晓明";
23. // 创建一个妻子对象
24. Wife baby = new Wife();
25. baby.name = "baby";
26. // 结婚【能通过丈夫找到妻子，通过妻子也可以找到丈夫】
27. huangXiaoMing.w = baby;
28. baby.h = huangXiaoMing;
29. // 得到以上“黄晓明”的妻子的名字
30. System.out.println(huangXiaoMing.name + "的妻子名字叫：" + baby.name);
31. System.out.println(huangXiaoMing.name + "的妻子名字叫：" + huangXiaoMing.w.name);
32. }
33. }

知识点

1. // 顾客类
2. public class Customer
3. {
4. // id
5. int id;
6. }
7. // ------------------------------------------------------------------------
8. // 测试程序
9. public class OOTest05
10. {
11. public static void main(String[] args){
12. Customer c = new Customer();
13. System.out.println(c.id); // 0
14. c = null;
15. // 以下程序编译可以通过，因为符合语法
16. // 运行出现空指针异常
17. // 空应用访问“实例”相关的数据一定会出现空指针异常
18. // java.lang.NullPointerException
19. System.out.println(c.id);
20. }
21. }
22.  
23. // “实例”相关的数据表示：这个数据访问的时候必须有对象的参与，这种数据就是实例相关的数据

1. /*
2. Java语言是面向对象
3. 要想创建对象必须先定义类
4. 定义类的语法：
5. [修饰符列表] class 类名{
6. 属性：
7. 方法：
8. }
9. 属性通常采用变量来表示，既然是变量那么变量肯定有数据类型。【数据类型包括：基本数据类型 + 引用数据类型】
10. 属性对应的是状态信息。
11. 观察现实世界当中超市中的商品，发现这所有的商品都有一些共同的特征，例如，每一个商品都有编号，每一个商品都有单价，所以定义以下的类，来代表所有的商品
12. */
13.  
14. public class Product{
15. // 编号 【通常是一个数字，而且该数字通常是整数型的】
16. // productNo 是基本数据类型
17. // 实例变量
18. int productNo;
19. // 单价 【通常是一个数字，但是数字可能带有小数，所以采用浮点型数据double表示】
20. // price 是基本数据类型
21. // 实例变量
22. double price;
23. // ----------------------------------------------------------------------
24. /*
25. 每一个类中都可以编写主方法，但是一般情况下
26. 一个系统只有一个入口，所以主方法一般写一个
27. */
28. public class ProductTest{ // 商品测试类
29. // 程序入口
30. public static void main(String[] args){
31. // 创建对象，商品对象
32. // iphone7 局部变量
33. // iphone7 应用
34. // iphone7 变量中保存内存地址的指向堆内存当中的商品对象
35. Product iphone7 = new Product();
36. // 访问实例变量的语法：引用.变量
37. // 读取：引用.变量名
38. System.out.println("商品的编号：" + iphone7.productNo);
39. System.out.println("商品的单价：" + iphone7.price);
40. // 修改：引用.变量名 = 值;
41. iphone7.productNo = 111;
42. iphone7.price = 68000;
43. System.out.println("商品的编号：" + iphone7.productNo);
44. System.out.println("商品的单价：" + iphone7.price);
45.  
46. }
47. }

1. // 人类
2. public class Ren{
3. // 身份证号
4. String id;
5. // 名字
6. String name;
7. // 性别
8. boolean sex;
9. // 年龄
10. int age;
11. }
12. // -------------------------------------------------------------------------
13. /*
14. 别墅类
15. * 面积
16. * 主人
17. */
18. public class BieShu{
19. // 面积
20. double mianJi;
21. // 主人【人类】
22. // 变量/应引用
23. // 变量怎么声明：数据类型 变量名;
24. // 关联关系： A has a B 关系【A对象中含有B对象的引用】
25. // BieShu对象含有Ren对象的引用
26. Ren zhuRen;
27. }
28.  
29. // ----------------------------------------------------------------------
30. public class Test{
31. public static void main(String[] args){
32. // 思路：先创造人物对象，再创造别墅对象，让别墅有主人
33. Ren zhangsan = new Ren(); // 初始化
34. // 不采用系统默认值
35. // 手动赋值
36. zhangsan.id = "45682110";
37. zhangsan.name = "张三";
38. zhangsan.sex = true;
39. zhangsan.age = 100;
40. // 创建别墅对象
41. BieShu fangzi = new BieShu();
42. fangzi.mianJi = 150.0;
43. fangzi.zhuRen = zhangsan;
44. // 想知道房子主人的名字是什么？
45. System.out.println(fangzi.zhuRen.name);
46. // 房子换主人
47. // 创建一个新的主人对象
48. Ren lisi = new Ren();
49. lisi.name = "李四";
50. // 换主人
51. fangzi.zhuRen = lisi;
52. System.out.println(fangzi.zhuRen.name);
53. }
54. }

1. // 学生类
2. class Student{
3. String name;
4. int no;
5. // 笔记本
6. Notebook book;
7. }
8.  
9. // ----------------------------------------------------------------------
10.  
11. // 笔记本类
12. class Notebook{
13. // 品牌
14. String brand;
15. // 型号
16. String model;
17. // 颜色
18. String color;
19. }
20.  
21. // ----------------------------------------------------------------------
22. /*
23. 需求：
24. 定义一个计算机类【电脑/笔记本】，计算机类有那些属性
25. * 品牌 * 型号 * 颜色
26. 定义一个学生类，学生类有那些属性：
27. * 姓名 * 学号 * 学生有一台笔记本电脑
28. 请编写程序来表示以上的类，然后分别将类创建为对象，对象数量不限，然后让其中的一个学生去使用其中的一台笔记本电脑
29. 然后编译并运行，并且将整个执行过程采用图形的方式描述出来。
30. */
31.  
32. // 测试类
33. public class OOTest06{
34. public static void main(String[] args){
35. // 创建笔记本对象
36. Notebook BiJiBen = new Notebook();
37. // 手动赋值
38. BiJiBen.brand = "华为";
39. BiJiBen.model = "KX100";
40. BiJiBen.color = "黑色";
41.  
42. // 创建学生对象
43. Student s = new Student();
44. // 手动赋值
45. s.no = 111;
46. s.name = "jack";
47. s.book = BiJiBen;
48. System.out.println(s.name);
49. System.out.println(s.no);
50. System.out.println(s.book.brand);
51.  
52. // 让这个学生和笔记本对象产生关系【通过学生能找到他的笔记本】
53. System.out.println("学号：" + s.no + " 名字叫 " + s.name + " 的电脑品牌是：" + s.book.brand);
54. System.out.println("学号：" + s.no + " 名字叫 " + s.name + " 的电脑品牌是：" + s.book.model);
55. System.out.println("学号：" + s.no + " 名字叫 " + s.name + " 的电脑品牌是：" + s.book.color);
56.  
57. // 修改品牌
58. s.book.brand = "苹果";
59. System.out.println("学号：" + s.no + " 名字叫 " + s.name + " 的电脑品牌是：" + s.book.brand);
60. }
61. }

总结

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注我们的更多内容！

原文链接：https://www.cnblogs.com/Axianba/p/14949743.html