服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - 新手初学Java面向对象

新手初学Java面向对象

2021-09-29 01:04群临天下 Java教程

这篇文章主要介绍了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. */

新手初学Java面向对象

  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. }

新手初学Java面向对象

  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. }

新手初学Java面向对象

  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. }

新手初学Java面向对象

知识点

新手初学Java面向对象

  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. // “实例”相关的数据表示:这个数据访问的时候必须有对象的参与,这种数据就是实例相关的数据

新手初学Java面向对象

  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

延伸 · 阅读

精彩推荐