java基础-1-面向对象（1）-概念介绍与类、对象、构造方法

------- android培训、java培训、期待与您交流！ ----------

什么叫做面向对象？

        想要了解什么事面向对象，我们首先需要了解，什么是面向过程。

        所谓的面向过程，指的是在编程期间，我们的思路走向和注重点，主要放在事物发展的过程之上。即忽略了是谁发出过程的动作，强调的是行为本身，而不是行为的发出者。相对而言，面向对象的出发点和面向过程正好是相反的。面向对象它本身的编程思想，主要强调的是发出动作的动作发出者的本身，并将事务进展的过程归结于对应的对象身上。没有对象，就没有它发出的动作，这就是面向对象的特点。

 

面向对象思想的由来

        如果我们说，面向过程是过程为先。那么，面向对象就是对象为先，对象包含过程。早期的BASIC、C等语言就是面向过程的语言，由于在编程语言的发展过程中，我们发现了每回都需要去大量的功能中，选择我们所需要的功能特别麻烦。所以，我们才开发出了面向对象语言。

 

面向对象的三大特征

        面向对象思想的最为显著的体现就是这三大特征：封装、继承、多态。

        只有实现了这三大特征的语言，我们才能将之称为面向对象语言。

        所以说，面向对象语言的使用特点，也由此派生而来。即：

                1.找对象、建立对象；

                2.使用对象；

                3.维护对象间关系。

 

类和对象：

        类：class（非Class，注意这点很重要），类是对现实事物的抽象描述。这里的现实事物，指的是Java中定义的各种具有一系列相关特点的概念的集合。

        对象：对象是由概念而来的具体实例化的个例。Java中，我们由类产生对应于该类所代表概念的个体。这种个体可以是单一的，也可以是复数的。即一个满足该类定义概念的实例，和多个在个性上有所区别的满足该类定义概念的实例。

        简单的来讲，类即是概念，对象即是概念的实体。即，概念上有：

class  ClassAndObject
{
       public static void main(String[] args)
       {
              //这个A就是一个概念的集合，我们将之称为类
              class A
              {
                     //这里面包含的就是这个概念的定义，以及实例化对象的方法
              }
 
              //下面的a就是一个由概念A派生出来的个体，我们称之为对象
              A a = new A();
       }
}

        类类型变量总是指向该类产生的实体，用以代表该实体。具体到实践中，我们通常都是这样用的：

class  TypistAndTyping
{
       public static void main(String[] args)
       {
              //我们使用打字员这个概念，来“任命”一位打字员a
              //即，用概念定义一个实例化的个体a
              typist a = new typist("Mr.Bang",1);
 
              //打字员开始打字。即，实体a调用自身方法：
              a.typing();
       }
}
//比如我们定义一个类，名称为打字员，那么一个打字员的任务是什么呢？
/*当然是打字啦。于是，这就是我们要做的，我们要为一个概念定义上他所
 *代表的方法，不论是特性方法，还是共性方法（通常，我们将个性方法都
 *放在另一个类中，用继承来实现就可以了）。
 */
public class typist
{
       /*既然我们定义了打字员这个类，那么我们就必须放点什么和打字员相
        *关的东西在这个类中。以便这个类有意义，Java中，我们默认是不定
        *义无意义的类的。而定义的项目中，包含了这个概念所具有的属性、
        *动作、初始化方法。
        */
 
       //属性-------------------------------------------------------------------
       //打字员是具有属性的，这些属性是由这个概念本身决定的，如：
       String id; //打字员编号
       int salary;  //打字员的薪金，不要问我为什么只有整数。。
 
       //功能-------------------------------------------------------------------
       //打字员该具有什么功能呢？当然是打字啦~
       void typing()
       {
              //原谅我这节的不正经吧。。
              System.out.println("typing");//没错，就是打字~
              //什么？你问别的方法？没有了。1块钱的员工，人家能给你打字就不错了。。
       }
 
       //构造方法---------------------------------------------------------------
       /*   我们上面定义了打字员这个类的对应属性和它的特有方法：打字。
        *接下我们就需要考虑，怎样来通过这个概念实例化一个该概念的实例了。
        *想要将一个类实例化，我们首先需要考虑的是这个类有没有必须初始化
        *的参数（即属性），如果没有，则定义一个空实例化方法即可，我们将
        *这种方法称为空构造函数。
        *    当一个类需要或者必须有初始化的参数时，我们就可以定义一个传
        *参的构造方法，这样的构造方法，我们称之为带参数的构造函数，简称
        *含参构造函数。
        */
        //很显然，打字员需要含参构造函数，我们假设没有数据不明的打字员
        void typist(String id, int salary)
       {
               //传参：
               this.id = id;
               this.salary = salary;
       }
}

 

构造方法：

        什么是构造方法，上面的例子中，我们已经给出了它的两种分类。即：空构造函数和含参构造函数。这里我们只解释一下构造方法这个概念本身。当然，作为一个概念，它本身就是可以设置为类的，而我们也在反射机制上这么做了，这就是Constructor类代表的概念。

        构造方法，指的是当一个已经设置为类的概念期望实例化一个该类相关对象的时候，所需要做的准备工作，包括了对该对象的初始化，和其他相关联操作，这样的一个过程。因此，构造方法本身还是一个过程。只不过，该过程发生在该类对象产生之前，是每个实例化对象所必须经历的过程。相同的同一类对象，如果构造方法只有一个，那么该类的所有对象的产生，所使用的构造方法都是完全相同的。而不同类之间，不考虑继承，就算是都只有空构造函数，其产生类的本质都是不一样的。

即，不同类的构造方法不同。

        注意：构造方法不用设定返回值（类型设为void即可），方法名必须和类名相同，且不能使用return语句。

 

构造代码块：

        什么是构造代码块？想要清楚什么是构造代码块，首先就得搞清楚什么是构造代码。构造代码，就是在某个类创建对象时，对对象进行初始化操作的代码。这和构造函数的不同在于，不论是什么样的构造函数，在调用构造函数之前，都会先执行构造代码进行操作。而构造代码块，就是指这些构造代码的代码块集合。例如：

classTectonicBlockDemo
{
       public static void main(String[] args)
       {
              //建立一个Man类对象a
              Man a = newMan("Mr.Bang",28);
              //显示a的信息
              a.show();
       }
}
 
public class Man
{
       //Man类的成员变量（属性）
       String name;
       int age;
 
       //构造代码块：
       {
              name = "wang";
              age = 18;
              System.out.println("haha!"+name+": "+age);
       }
 
       //构造方法：
       void Man(String name, int age)
       {
              this.name = name;
              this.age = age;
       }
 
       //显示信息函数
       public void show()
       {
              System.out.println(name+":"+age);//注意显示的和构造代码块不同
       }
}

        上面这道例题的结果为：haha!wang: 18

                                                    Mr.bang: 28

        从结果，我们不难发现，构造代码块先于构造函数执行。

        实际上，我们的执行顺序可以简略的写为：父类->静态构造代码块->构造代码块->构造函数

 

补充：匿名对象

        什么叫做匿名对象？匿名对象就是指不用类类变量指定的对象，就是匿名对象，比如说：        

	new typist("K", 20 );  //这就是一个匿名对象

        因此，我们可以看出，如果我们只需要使用一次该类的实例，我们就可以使用这种匿名对象的方式，来创建一个实例，调用我们需要的变量、方法（通常这种情况都是调用方法）。当然，我们还有更简便的方式，即使用public修饰对应方法即可。但是public修饰的这种方式，在某种需要保护该方法，但又期望通过反射调用一次该对象的方法的情况，我们就可以使用这种方式。当然，这种方法只是对具体情况的一种折中的方式，个人认为，应该视具体情况而定进行使用。

        匿名对象也可以用作实际参数传递。这通常用于对某个同类对象的重新还原初始设置之用。比如：

class anonymousObject
{
       public static void main(String[] args)
       {
              //建立B类对象b，并为成员变量i其赋初值2
              B b = new B(2);
              //显示对象b中的i值
              b.show();
 
              //使用匿名对象，来重新初始化对象b
              b = new B();
              //显示对象b，在重新初始化后的i值
              b.show()
       }
}
 
//测试类B：
public class B
{
       private int i = 1;
 
       //B类构造函数
       void B(int i)
       {
              this.i = i;
       }
       void B(){}
 
       //成员变量i的显示函数
       public void show()
       {
              System.out.println(i);
       }
}

        上面这个例子中，我们就使用了匿名对象来再次初始化已经对成员变量赋过值的B类对象b。从结果不难看出，原来的i值2，经过匿名对象的初始化，变成了1。实现了还原。

------- android培训、java培训、期待与您交流！ ----------