JavaSE基础知识(五)--面向对象思想概述

Java SE 是什么，包括哪些内容(五)？

本文内容参考自Java8标准

一、面向对象:

• 1、回顾前面的博文（“了解这个开头，更有利于了解对象以及面向对象的思想”）
  首先我们知道，计算机只认识0和1(这是一个非常重要的基础)，所以，在前面博文提到的类型分以下三种：
  整数类型:
  byte:存储空间是8位二进制，范围是-128~127。
  示例:用它来表示96：0110 0000。
  short:存储空间是16位二进制，范围是-32768~32767。
  示例:用它来表示96：0000 0000 0110 0000。
  char:存储空间是16位二进制，范围是’\u0000’ to ‘\uffff’，即0~65535(它是没有符号位的，所以16位全部用来表示真值，)。
  示例:用它来表示96：’\u0060’。
  应用代码示例:
  
  int:存储空间是32位二进制，范围是-2147483648~2147483647。
  示例:用它来表示96：0000 0000 0000 0000 0000 0000 0110 0000。
  long:存储空间是64位二进制，范围是-9223372036854775808~9223372036854775807。
  示例:用它来表示96：0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0110 0000。
  浮点数类型:
  float:存储空间是IEEE 754标准下的32位二进制，范围是1.40e^-45–3.4028235e³⁸。
  示例：用它来表示5.23:1 00000001 10000000000000000000000
  double:存储空间是IEEE 754标准下的64位二进制，范围是4.9e^-324–1.7976931348623157e³⁰⁸。
  示例：用它来表示5.23:1 0000000000000001 10000000000000000000000000000000000000000000000
  布尔类型:存储空间是32位二进制(数组中的布尔类型是8位二进制)，它谈不上范围，因为它总共就只有两个值：true和false。凑巧的是，它的值刚好能用0和1分别表示。
  因为它只有两个值：true和false。所以0表示false,1表示true。
  以上的示例不保证是正确的，希望各位读者能理解这里面的思想！！
  通过总结以上内容我们能看出，这三种类型(整数类型、浮点数类型、布尔类型)能完全用0和1表示，它们的计算无非就是二进制的运算(因为都是用一长串的0和1表示的)，换个角度也可以说，它们的完全是基于计算机硬件的(计算机硬件只认识0和1)，根本未脱离计算机硬件本身—所以他们称为"基本类型"。在编程过程中，它们是编程中的最基本单元，你可以直接在程序中使用，但是最大的问题在于：如果Java中只有这三种类型，那么，它的编程范围就大大的受限了。能实现的功能可以说是屈指可数，最根本的问题是人们的编程思维将因硬件条件而极大受限(思维的丰富性和0，1的单调性有强烈的矛盾)，程序中涉及到的任何内容，都必须抽象成这三种类型的其中一种或多种来表示—因为除了这三种类型以外，你再找不到其他的类型了。
  幸运的是：Java还有一种很宽泛的类型—类类型，你可以将世间万物都抽象成一种类类型，这比将世间万物都抽象成整数类型、浮点数类型、布尔类型其中之一或者它们的组合要轻松得多。

• 2、如何将世间万物抽象成类类型？(通过这点，你将能更深刻认识到，为什么Java中号称"一切皆为对象"，但是在此之前，我们必须先了解，在Java中如何声明一个类类型。)
  那么，我们应该如何来声明一个类类型呢？
  我们回到基本类型，我们知道声明一个整数类型，是通过以下五个关键字：byte、short、char、int、long，声明一个浮点数类型是通过以下两个关键字：float、double，声明一个布尔类型是通过以下关键字：boolean。那么声明一个类类型，是不是也有一个关键字?对，有的，它就是"class"。
  那么，具体声明一个类类型包括哪些内容呢？
  我们再回到基本类型，我们知道声明一个整数类型包括以下内容(另外两种类型：浮点数类型，布尔类型，格式都是一样的，除了关键字不一样)：

  类型关键字	标识符	等号	值
  byte	a	=	5
  short	a	=	5
  char	a	=	5
  int	a	=	5
  long	a	=	5
  …	…	…	…

  代码示例:

    // 声明一个整数类型
       byte a = 5；
       short a = 5；
       char a = 'a'；
   　  int a = 5；
   　  long a = 5l；
  

  那么，声明一个类类型包括以下内容

  类型关键字	标识符	大括号
  class	a	{ }

  代码示例:

   // 声明一个类类型
     class a { }
  

  从以上代码我们可以看出，如果仅仅只有"class a { }"，这三个内容，声明的这个类类型是空的，因为"{ }"里面没有任何内容，仅仅是一个声明，对于实际的编程没有任何意义(对应至基本类型，基本类型都是在"=“后有具体的值，所以，类类型具体的内容，应该全部都在”{ }“里面。因为现在声明的这个类类型的”{ }"里面没有任何的内容，所以这个类类型是空的)。
  那么，我们应该如何声明一个实际有用的类类型呢？
  上文提到了，类类型是和世间万物一一对应的，也就是说，任何有形无形，只要是说的出来，看得见的东西，都能通过Java中的类类型进行表示(这就是一个抽象的过程，将所有实在的事物都抽象成代码表示)。
  下面举例示范一下抽象的过程
  那我们来谈一谈，如何将汽车类型抽象成Java代码的表示(也就是说到底是哪些代码能表示具体生活中的汽车)。
  首先，先声明一个汽车类型，标识符就用"car"吧：

   // 声明一个汽车类型
   class car { }
  

  要表示一辆汽车，先从外观来看吧，就是长宽高了。
  那么长宽高是什么呢？就是一个数值，数值可以用什么来表示呢？基本类型，又因为长宽高不一定是一个整数，所以选择浮点数合适，又因为float类型的范围足够，所以就用float类型。
  增加长宽高 ：

    // 增加了长宽高
    class car {
           float length = 0；
           float width = 0；
           float height = 0；
     }
  

  除了外观以外，还有什么内容呢？还有汽车的重量，颜色，品牌，最高时速，舒适度，价格等等，就相当于你去买汽车，以上内容都是你关心的重点吧。那我们把这些内容也加上。

  // 增加了重量
  class car {
         float length = 0；
         float width = 0；
         float height = 0；
         //增加重量，float类型
         float weight = 0；
   }
  

  现在遇到问题了，颜色怎么增加？颜色不能直接用一个数值来表示，所以整数类型、浮点数类型都不行，那么布尔类型行不行，不行，因为布尔类型就两个值，而颜色有多个，那么，怎么来处理？这个时候，只能将颜色抽象成一个类类型了(因为总共就整数类型，浮点数类型，布尔类型，类类型四种，前面三种都不行，就只有第四种了。)！
  于是，我们试着将颜色抽象成类类型，一般来说，我们最先想到的就是诸如**“red”、“green”、"yellow"等这些表示颜色的字符串**(字符串类型如果有需要详细了解的，请关注后期博文)，所以，我们先声明一个颜色的类类型，这个类型需要包含所有的表示颜色的字符串：

    // 表示颜色的类类型
    class color { }
  

  然后每种颜色都需要一个字符串对象来存储(这里提到了对象这个概念，需要详细了解的，可以关注后续博文，目前看到这里，你只需要知道有这么个东西就行)：

  // 表示颜色的类类型
  class color {
     String red = "red"；
     String green = "green"；
     String yellow = "yellow"；
     ....
     //如果有多种颜色，每一种颜色都需要一个String对象来存储。
     //虽然这是一种可行的办法，但是对于目前的开发需求来说，
     //并不是最优的办法。
  }
  

  我们先组合起来看一下：因为颜色的类类型，我用的标识符是"color"，所以在汽车类型里面我需要这么声明：

  // 增加了重量，颜色
  class car {
         float length = 0；
         float width = 0；
         float height = 0；
         //增加重量，float类型
         float weight = 0；
         //增加了颜色类型，Java中可以声明任何类型，
         //并且使用起来没有问题。
         //这里可以说是car类型包含了一个color类型
         color c = null；
         //为什么这里是"null"，目前你只需要知道在这里是
         //这么操作就行了。
    }
  

  从以上代码中我们可以看到，我们随意声明的类型(color)，可以放进另外一个我们随意声明的类型(car)里面。这将极大方便我们编程，因为随时可以按需创建类类型且随时使用。这在正式的Java规范中有一个很形象的称谓：“组合”，意思是各个类类型之间的组合，然后生成了一个新的类类型(如果各个类类型之间组合的好，那么代码就能很健壮！)。
  那么，我们继续来考虑一下，是否有比color类类型更好用，更简易的类类型？
  这里有一个重点的问题需要提及，就是类类型实际上有四种，第一种就是我们自己根据实际编程需要而创建的类类型，第二种实际上也是我们根据实际编程需要而创建的类类型，但是因为功能的不同，它有一个固定的称谓"接口"，第三种是Java语言本身提供的类型，它也有一个固定的称谓"数组"，第四种实际上就是一个值：null(它不是重点，在这里不详细说明)
  Java语言本身就提供了一种很通用的类类型，它就是著名的数组(因为是Java语言本身就提供的，所以直接可以拿来使用。)，数组的思想是能有序管理多个对象(这里又不得不提到了**"对象"这个概念，即使这样，在这里，你还是只需要知道有这么个东西就行)，也就是说，一个数组对象里面能存储多个其他的对象**，并且存储的这些对象是有序的！，这里有必要提一下数组(这里只是提一下，详情可关注后续博文)：
  ⑴、如何声明一个数组(它包括以下内容)：

  类型标识符	中括号	标识符	等号	值
  String	[]	s	=	{ }

  这里还需要重点提一下这个**“类型标识符”，为什么不叫类型关键字**，而叫类型标识符呢？因为个人觉得类型标识符更恰当，因为你除了可以声明String类型的数组，还可以声明car类型，color类型以及其他任何类型的数组，你需要声明哪种类型的数组，就使用那种类型的类型标识符。
  代码示例(声明一个String类型的数组)：

   // 声明一个String 类型的数组
     String [] s = { }；
     }
  

  如果仅仅是String [] s = { }；这种形式，那么这个String类型的数组s对实际的编程意义不大，因为"{}“里面没有放入任何内容，即使标识符s已经被初始化，同时”{}"的出现已经导致了一个对象创建完成，实际上，这个对象里面是没有任何东西的。我们来看一下这个s初始化的值是什么：
  
  从结果中可以得出，当前这个数组标识符s代表的内存空间存储的是这个对象在堆中的地址。也就是说，所有的值栈中的对象标识符代表的存储空间都是存储实际对象在堆中的地址。
  +++++++++++++++++++++++++++++++++++++++++++++++++
  希望你们还能跟得上，因为这里，我有需要说一下**“初始化”**是怎么回事。
  我们还是回到三种基本类型：整数类型、浮点数类型、布尔类型。当我们这么声明(拿int类型来举例)：

  // 声明一个int类型
   int a；
    }
  

  如果仅仅只是像如上代码这样声明一个int 类型，同时也有了标识符a，那么代码运行到这里，执行的内容仅仅是在硬件的堆栈上开一个存储空间，空间的名字为a，但是这个空间里面没有内容，所以，合理的方式是声明一个int类型，命名一个标识符a，同时也需要给a 赋值，完整的形式就是int a = 5；这样，这个名字为a的存储空间里面才会存储一个值，这个值就是赋值的数值，而赋值的操作在Java规范里面就叫"初始化"(Java的设计者考虑到了声明但是不赋值的情况，所以，Java中默认会为你声明的整数类型，浮点数类型，布尔类型分别赋值0，0.0，false)。
  Java中默认赋值的示例：
  
  那么，类类型的初始化是怎么样的？如果不进行初始化，Java默认初始化的值是什么?这里顺带提一下，类类型的声明代码是 ：

  类型	类型标识符	存储空间标识符	等号	值
  类类型	color	c	=	new color()
  数组	String[]	s	=	{ }
  接口	Color	s	=	new 子类型()
  null	-	-	-	-

  我们可以看出，四种类型的声明以及初始化的代码形式都不尽相同(null实际上就是一个值，其他内容它都没有)。
  类类型是通过关键字new，调用构造方法创建一个对象进行赋值，它的存储空间名称标识符代表的是值栈中的一个空间，这个空间里面存储的是实际对象的内存地址，那么实际的对象内容存储在哪里呢?存储在堆中，这种存储方式是和C以及C++中不一样的。这种方式有利于代码专注于功能实现，而将附加的对象销毁工作分离开来，所以，Java中有了垃圾回收器，解决了对象之间相互依赖何时销毁的复杂问题，也就是说，在代码运行过程中，甚至都可以不销毁对象，待程序结束了之后，再启动垃圾回收器去销毁实际的对象，释放内存空间。
  ⑵、如何初始化一个数组(它包括以下内容)：
  数组类型和类类型是一样的操作，只是它的初始化的方式有两种，第一种就是我们上文使用的String[] s = { }：根据初始化的内容数量来创建内存空间，内容必须全部输入在大括号中，并且用逗号隔开；还有一种是String[] s = new String[6]：根据固定的内存长度来存储内容，赋值的时候必须用数组下标表示；
  代码示例：
  
  接口类型这里暂时不提。
  null是怎么回事呢?实际上，它就是一个值，当类类型，数组类型，接口类型只有类型标识符和存储空间标识符，堆中还没有创建实际的对象与他们的标识符相关联，这个时候，与这个标识符关联的就是null：
  代码示例(以下代码中如果有看不懂的，不要紧，请关注后续博文更新)：
  
  从以上示例中可以看出，只要是没有初始化的类类型，值都是null，null对于类类型就相当于0对于整数类型，0.0对于浮点数类型，false对于布尔类型。
  初始化的内容就提到这里。
  注意，未初始化的类型不能使用，但是在Java中，所有类型都会被默认初始化，只是，类类型如果被初始化为null，而再某一处需要使用它，就会产生一个运行时错误：空指针错误，无论新手老手都会遇到。
  +++++++++++++++++++++++++++++++++++++++++++++++++
  我们继续来看一下：String [] s = { }：
  代码示例：
  
  因为没有往"{ }“中放任何内容，也不涉及内存空间开辟的操作，所以你在尝试打印的时候，是完全空！而String[] s = new String[6]；只是它开辟的这6个空间没有被正确初始化(因为全部被初始化为了"null”,而不是实际编程中需要使用的对象)，由此得出null实际上是开辟了值栈空间，但是没有存储任何内容。
  ⑶、如何初始化一个数组对象的内容？–如果是"{}"，就是如何往"{}"放内容，如果是new String [6] 则如何初始化这6个内存空间(它包括以下内容)：
  这个时候，我们往"{ }"放一些内容进去，回到前面，就放有关颜色的字符串对象吧。

     // 初始化一个String数组，往"{}"
     //放一些东西。
    String[] s = {"red"，"yellow"，"green"}；
    //实则就是将每个同类型的对象按序放入，
    //用"，"分隔。比如字符串对象。
  

  现在，用这个数组来代替之前的color类，我们来看一下效果：

  // 增加了重量，颜色
  class car {
         float length = 0；
         float width = 0；
         float height = 0；
         //增加重量，float类型
         float weight = 0；
         //用数组来表示颜色
         String[] s = {"red"，"yellow"，"green"}；
    }
  

  接下来的品牌，最高时速，舒适度，价格

       // 增加了品牌，最高时速，舒适度，价格
   class car {
         float length = 0；
         float width = 0；
         float height = 0；
         //增加重量，float类型
         float weight = 0；
         //用数组来表示颜色
         String[] s = {"red"，"yellow"，"green"}；
         //用数组来表示品牌
         String[] p = {"toyota"，"Honda"，"Benzi"}；
         //用int表示最高时速
         int HightSpeed = 0；
         //用布尔类型来表示舒适度
         boolean flag = false；
         //用float表示价格
         float pricae = 0.0f；
         }
  

  以上代码对于描述一辆车来说，应该是足够了。至于最后你看到的实际效果只是因为前端的设计，加上了图片等，比如你如果选择了"yellow"，说明是黄色的，这个时候，前端需要渲染成黄色，所以用color类型或者是字符串数组都能表示颜色，因为他们都可以存储在数据库中，只需要从数据库读取出来，和前端的实际效果一一对应就行。
  接下来还缺了什么呢？
  以上的内容仅仅只是描述一辆汽车，那么我们能不能让它动起来呢？能不能让它动起来以后再停下来呢？能不能加速？能不能减速？为什么我们会有这样的想法，因为实际中的汽车确实是有这些功能的。那么，如何用代码来实现这些具体的动作呢？
  可以的，在Java中，如果要对应这些功能，必须用到方法。
  我先来简单描述一下实际中的汽车行为和代码中的汽车行为是怎么对应的。实际中的汽车行为是用车钥匙启动，挂档，采油门，走人。
  但是在代码中可能只需要实现这么一个功能，就是给你一张汽车图片，你需要在瞬间移动汽车图片的位置，并且不要停，让人看起来，这个汽车是在连续不停地移动(实际上是图片在动)，这就是开走了，然后怎么让人感觉汽车轮胎在动呢？还是这个套路，你可能需要两到三张不同的汽车轮胎图片，然后不停地在这几张图片之间进行切换，让人看起来轮胎也似乎"动起来"了。
  通过以上的描述，你可以发现一个根本性的问题，如果需要实现以上的功能，我们需要不止一句代码，我们需要很多句代码，确实是这样，在Java中，如果你需要一次性调用多行代码，不可能在每次调用的地方，都把这些代码写一遍，所以，你可以把这些代码都写在一个块中，给这个块也命名一个标识符，你需要用这许多代码的时候，就用一句代码调用这个标识符就行，等同于调用了这个块里面的所有代码(Java内部机制)，这个块在Java规范中，叫做"方法"。
  我们来看一下Java方法由哪些要素组成：

   // 声明一个方法
    public void start(){ 
    //所有的代码都放在这个"{ }"里面。
   }
  

  public是权限修饰(后续博文会详解权限问题)
  void是表示这个方法未返回任何东西，它的代码只需要顺序执行，有的方法会在执行完毕后得到一些结果，需要将结果返回，又因为Java是强类型的语言，所以需要在方法的开始处就规定返回结果的类型，这里的"void"对于方法就类似"null"对于类类型。表示什么都没有返回。
  “start"就是这个方法的标识符，”()“这个括号虽然看上去简单，但是实际上作用很大，就拿上面这个汽车移动的代码实现来描述：
  首先你需要在代码中写一个汽车的图片，应该是用String类型。
  比如：String s = “C:\Users\Administrator\Desktop\a.png”；表示引用的是这个地址的图片，然后使用一个定时器，固定多少毫秒就变动这个图片的位置，再来几行代码表示图片的移动方向等等，你会发现一个问题，就是除了这个图片，其他的代码都是通用的，如果我有其他几百张的汽车图片，可能剩余的代码我也需要赋值几百遍，这也是一个很大的问题，能不能就写一个方法，能让所有的汽车图片都"动起来”?可以的，你需要将这个图片的String，放在这个"()"里面。然后在代码中，你所需要做的就是处理这个标识符s比如：

  //带参数的方法
  public void start(String s){
     //相同的代码都写在这里
  }
  

  将代表图片的字符串放在了方法的"()“里面，将所有通用的代码都放在了方法的”{ }"中，这样，你就能在调用方法的时候再决定传入哪个图片，有点来料加工的意思，也就是说，你在调用方法的时候，可以直接传入一个字符串对象，这个字符串对象就将这个"s"初始化了。无论你传入的是什么图片，这个"s"都代表了这个图片，所以，在方法的内部对图片的处理，都能转化成对这个标识符"s"的处理。
  如果在方法的括号里是有类型参数的，那么在实际调用方法时传入值或者对象就是对这个参数类型进行初始化了，方法"()"里的参数直到方法被调用的时候才进行初始化

   //调用带参数的方法
     start( "C:\Users\Administrator\Desktop\a.png")；
  }
  

  可以看到，调用方法很简单，就是方法标识符+"()"，比如：“start()”，如果在方法声明的时候，括号里面没有声明类型参数，那么括号空着就行，如果有类型参数，就需要传入对应类型的值或者对象(基本类型是值，类类型是对象)：
  start( “C:\Users\Administrator\Desktop\a.png”)；这句代码的意思就等同于：
  1、先将s进行初始化，初始化的对象是：“C:\Users\Administrator\Desktop\a.png”。
  2、再调用start()。这里的start()代表的是"{ }“里面的通用代码。如果这个时候”{ }"里面的代码用到了s，则s不再是null。
  我们继续将汽车类型的代码完善，给它加上一些方法：

         // 增加了一些对应的方法。
     class car {
           float length = 0；
           float width = 0；
           float height = 0；
           //增加重量，float类型
           float weight = 0；
           //用数组来表示颜色
           String[] s = {"red"，"yellow"，"green"}；
           //用数组来表示品牌
           String[] p = {"toyota"，"Honda"，"Benzi"}；
           //用int表示最高时速
           int HightSpeed = 0；
           //用布尔类型来表示舒适度
           boolean flag = false；
           //用float表示价格
           float pricae = 0.0f；
            //启动的方法
            public void start(){}；
            //加速，实际上就是让图片移动的快一点
            public void UpSpeed(String s){}；
            //减速，实际上就是让图片移动的慢一点
            public void DownSpeed(String s){}；
            //左转，实际上就是将图片的位置左移
            public void TurnLeft(String s){}；
             //右转，实际上就是将图片的位置右移
            public void Turnright(String s){}；
            //倒退，实际上就是将图片往后移
            public void ToBack(String s){}；
             //熄火，实际上就是停止图片的移动
            public void stop(String s){}；
            //保养，实际上就是换一张更好看的图片。
            public void ChangePicture(){}；
           }
  

  以上内容，如果你能完全理解，那么有助于你更好地理解API文档，你首先需要聚焦思考，创建这个对象是为了什么，看一下都有那些描述它的标识符以及它能干什么(方法)。
  总结：上文提到的诸如长，宽，高，价格，舒适度等这些描述性标识符实际上是描述了汽车的状态，而方法实际上表示了汽车所有的行为，整个编程过程中，就是在不断地改变对象的状态以及调用对象的行为。
  如果以上内容你全都能明白，那么对于对象的理解是水到渠成的事情，上文的内容，主要是类类型这块，已经将一种类型所有的状态，行为都固定好了，现在你需要在这种类型的基础上，去不断创建对象，比如创建一辆长、宽、高分别是5.7、3.2、2.1的汽车，一辆长宽高分别是5.9、3.3、2.0的汽车，,每个对象将拥有不同的状态，但是它们具有相同的行为。最后，你需要知道，创建对象的代码是(通过关键字"new"创建一个car类型的对象)：
  car c = new car()；这个类型标识符"c"引用了堆中的一个car对象。
  后续博文将分别针对状态，方法，对象进行详细分析，这边博文只是将他们简单串联起来，有一个总体的框架性认识。

PS：时间有限，有关Java SE的内容会持续更新！今天就先写这么多，如果有疑问或者有兴趣，可以加QQ：2649160693，并注明CSDN，我会就博文中有疑义的问题做出解答。同时希望博文中不正确的地方各位加以指正！