黑马程序员-------------面向对象和类

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

面向对象和类

我把面向对象程序设计简单的归纳为：“向对象发送消息”！
为什么叫向对象发送消息呢？因为当我们把现实中具有公共性质和功能（即方法）的具体的很多对象抽象出来封装成一个类时 ，其实我们的思考就是我们要怎样做能（即指挥）给这些具有公共性质和功能（即方法）的具体对象干某件事情呢。这就体现了面向对象的一个特性——封装。当我们把某一类具有公共性质和功能的事物进行封装之后就不再关心事物是具体怎样去干某件事情的，关心的是能不能指挥这类事物干某件事情（即该类事物具备要去干某件事情的功能吗）和怎样去指挥这类事物干某件事情  。我们就从事情的操作者变成了事情的指挥者。这一过程具体的体现就叫向对象发送消息！ 当要给这类事物发送消息时我们只要指明是某个实例对象就行，即就把我们抽象出来的类再实例化成具体的某一个对象，再给这个具体的实例对象发送消息就行了。这个消息就是通常说的要访问某个对象的“属性或方法”。而当我们把一类事物封装成类以后就给这类隐性的贴了一个标签，这标签就是给外部说我这个类只能接受或说识别哪些消息不能接受或识别哪些消息。当外部一定要给我这类发送我不能接受的消息时，就会报错。

Java是面向对象的程序设计语言，Java语言提供了定义类、定义属性、方法等最基本的功能。类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，它们将会引用到类的对象，对象由类负责创建。类用于描述客观世界里某一类对象的共同特征，而对象则是类的具体存在，Java程序使用类的构造方法来创建该类的对象。

例如一个学生这个实体对象他有姓名和年龄的属性，和学习的功能，那么另外个学生也有这些属性和功能，只要他是一个学生。故我们可以把学生这一类的人可以抽象成一个类而某一个学生就是这个类的一实例对象。封装成的这个学生类有姓名和年龄的私有属性和公共的学习的功能即方法。当我们要想知道某个学生的姓名时 ，我们就再也不去执行怎样去知道学生姓名的过程而是通过构造方法生成一个学生实例对象，再通过该实例对象的名称去访问他的姓名属性即可。执行者就变成了指挥者。在实际操作中如下列子；Student是一个类，Student s = new Student（）；s.getName()（即在给s这个对象发送消息消息内容就是想知道学生的名字）就完成了知道某个学生的名字的事。

class Student{private int age ;private String name;public Student(){}public Student(int age,String name){this.age =age;this.name = name;}public int getAge(){return age;}public void setAge(int age ){this.age = age;}public String getName(){return name;}public void setName(String name){this.name = name;}

       public void study(Student s ){System.out.println(s.getName() + "he reads books");}

}

一面向对象的特点：

1：将复杂的事情简单化。 
2：面向对象将以前的过程中的执行者，变成了指挥者。 
3：面向对象这种思想是符合现在人们思考习惯的一种思想。  
过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。  
二匿名对象使用场景： 
1：当对方法只进行一次调用的时候，可以使用匿名对象。 
2：当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。  
在类中定义其实都称之为成员。成员有两种：

 1：成员变量：其实对应的就是事物的属性。

 2：成员函数：其实对应的就是事物的行为。  
所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。  
private int age;//私有的访问权限最低，只有在本类中的访问有效。 注意：私有仅仅是封装的一种体现形式而已。

私有的成员：其他类不能直接创建对象访问，所以只有通过本类对外提供具体的访问方式来完成对私有的访问，可以通过对外提供函数的形式对其进行访问。 
好处：可以在函数中加入逻辑判断等操作，对数据进行判断等操作。

总结：1 开发时，记住，属性是用于存储数据的，直接被访问，容易出现安全隐患，所以，类中的属性通常被私有化，并对外提供公共的访问方法。 这个方法一般有两个，规范写法：对于属性 xxx，可以使用setXXX(),getXXX()对其进行操作。  
类中是否要定义主函数呢？ 
  注 意：主函数的存在，仅为该类是否需要独立运行，如果不需要，主函数是不用定义的。 

主函数的解释：保证所在类的独立运行，是程序的入口，被jvm调用。  
三成员变量和局部变量的区别： 
1：成员变量直接定义在类中。  局部变量定义在方法中，参数上，语句中。

 2：成员变量在这个类中有效。 局部变量只在自己所属的大括号内有效，大括号结束，局部变量失去作用域。

 3：成员变量存在于堆内存中，随着对象的产生而存在，消失而消失。 
局部变量存在于栈内存中，随着所属区域的运行而存在，结束而释放

四构造函数

构造函数：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。 特点： 
1：该函数的名称和所在类的名称相同。 

2：不需要定义返回值类型

3：该函数没有具体的返回值。 
记住：所有对象创建时，都需要初始化才可以使用。  
注意事项：一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。  
一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。 

构造函数和一般函数有什么区别呢？

 1：两个函数定义格式不同。 
2：构造函数是在对象创建时，就被调用，用于初始化，而且初始化动作只执行一次。     一般函数，是对象创建后，需要调用才执行，可以被调用多次。

class Person {private String name;private int age;public Person() {//空参数的构造方法}public Person(String name, int age) {//指定参数的构造方法super();this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}

}

public static void main(String[] args) {Person p =new Person("zhangsan" ,12);//用构造方法创建类的实例一个对象p}

构造代码块和构造函数有什么区别？ 

构造代码块：是给所有的对象进行初始化，也就是说，所有的对象都会调用一个代码块。只要对象一建立。就会调用这个代码块。 
构造函数：是给与之对应的对象进行初始化。它具有针对性。  

五创建一个对象都在内存中做了什么事情？   Person p = new Person(); 
1：先将硬盘上指定位置的Person.class文件加载进内存。 
2：执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。 
3：在堆内存中开辟一个实体空间，分配了一个内存首地址值。new 

4：在该实体空间中进行属性的空间分配，并进行了默认初始化。

 5：对空间中的属性进行显示初始化。

 6：进行实体的构造代码块初始化。 
7：调用该实体对应的构造函数，进行构造函数初始化。（）

 8：将首地址赋值给p ，p变量就引用了该实体。(指向了该对象)

this:代表对象。就是所在函数所属对象的引用。 
this到底代表什么呢？哪个对象调用了this所在的函数，this就代表哪个对象，就是哪个对象的引用。 开发时，什么时候使用this呢？ 
在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。  
this 还可以用于构造函数间的调用。

调用格式：this(实际参数)； 
this对象后面跟上 .  调用的是成员属性和成员方法(一般方法)； this对象后面跟上 () 调用的是本类中的对应参数的构造函数。  
注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。

六单例设计模式：

保证一个类在内存中的对象唯一性

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到

的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到

的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

比如：多程序读取一个配置文件时，建议配置文件封装成对象。会方便操作其中数据，又要保证多个程序读到的是同一个配置文件对象，就需要该配置文件对象在内存中是唯一的。

如何保证对象唯一性呢？

 思想： 
1，不让其他程序创建该类对象。

2，在本类中创建一个本类对象。 
3，对外提供方法，让其他程序获取这个对象。 
 
步骤： 
1，因为创建对象都需要构造函数初始化，只要将本类中的构造函数私有化，其他程序就无法再创建该类对象； 
2，就在类中创建一个本类的对象； 
3，定义一个方法，返回该对象，让其他程序可以通过方法就得到本类对象。（作用：可控）  
代码体现： 
1，私有化构造函数； 
2，创建私有并静态的本类对象； 
3，定义公有并静态的方法，返回该对象。

 
 //懒汉式:延迟加载方式。

class Single{private Single(){}private static Single s  =  null;private static Single getInstaance (){if(s==null)s = new Single();return s;}}

//饿汉式

class Single{private Single(){}private static Single s  = new Single();private static Single getInstaance (){return s;}}

内部类

一内部类的定义

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

        当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。如定义一个描述人的类，而手、心脏等都属于人，然它们又有自己的功能描述，这时可以在人这个描述类中，定义一个描述心脏的类，也就是内部类。

        编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Test$1.class。编译器将会把内部类翻译成用$（美元符号）分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。

 

二、内部类的访问规则

        1、内部类可以直接访问外部类中的成员，包括私有。

              之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：  外部类名.this。

        2、外部类要访问内部类，必须建立内部类对象。

 

三、访问格式

1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。

        格式：

                 外部类名.内部类名  变量名 =外部类对象.内部类对象；

        如：    Outer.Inner in =new Outer().new Inner();

当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：

        private：将内部类在外部类中进行封装。 

        static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，直接访问static内部类的非静态成员的格式为：

        new 外部类名.内部类名（）.方法名（）；

        如：new  Outer.Inner().function();

在外部其他类中，直接访问static内部类的静态成员格式为：

        外部类名.内部类名.方法名（）；

        如：Outer.Inner.function();

注意：

        1）当内部类中定义了静态成员时，该内部类必须是static的。

        2）当外部类中的静态方法访问内部类时，内部类也必须是static的。

        3）在实际应用中，内部类通常被定义为private，而很少定义为public。

2、内部类定义在局部

        内部类定义在外部类中的某个方法中，创建了这个类型的对象时，且仅使用了一次，那么可在这个方法中定义局部类。

        1）不可以被成员修饰符修饰。如public、private、static等修饰符修饰。它的作用域被限定在了声明这个局部类的代码块中

        2）可以直接访问外部类中的成员，因为还持有外部类中的引用。

注意：内部类不可以访问它所在的局部中非最终变量。只能访问被final修饰的局部变量。

public class InnerDemo { public static void main(String[] args)       {          Outer out = new Outer();          out.method();// 打印的是5    }  }class Outer {      int x = 5;      class Inner{    void show(){    System.out.println(x);    }    }    void method(){    Inner in = new Inner();    in.show();    }    }   

四、匿名内部类

        1、匿名内部类其实就是内部类的简写格式。

        2、定义匿名内部类的前提：

              内部类必须是继承一个类或者实现接口。

              特殊情况：因为所以的类都有一个父类Object，所以在定义时也可以用Object。

        3、匿名内部类的格式：  new父类或者接口(){定义子类的内容}

        4、其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象。

        5、匿名内部类中定义的方法最好不要超过3个。

匿名内部类的利与弊：

        好处：简化书写

        弊端：1、不能直接调用自己的特有方法、

                     2、不能做强转动作。

                     3、如果继承的父类或接口中有很多方法时，使用匿名内部类阅读性会非常差，且调用会很麻烦。所以匿名内部类中定义的方法有一般不超过3个。

[java] view plaincopyinterface Inter  {      void method();  }  class InnerClassTest   {      public static void main(String[] args)       {          show(new Inter()          {              public void method()              {                  System.out.println("method show run");              }          });      }        public static void show(Inter in)      {          in.method();      }  }  

</pre><p></p><pre>