黑马程序员——Java基础知识——面向对象(一)

                ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！

 一、什么是面向对象

         当你想要用一件东西完成一个动作或做一件事情时，这个动作或这件事情是这件东西可以完成的动作，我们要做的就是指挥这件东西，告诉它去做。比如开门，   我们只是转一下把手，给门一个要打开的信号，然后门通过自己具备的功能，转动门轴、合页等，实现门的打开。这就是Java中的面向对象的思想。C语言中是面向   过程思想，强调功能行为，例如：打开门——关闭门。而Java中的面向对象的思想是基于面向过程的思想而来的，强调具有功能的对象，例如：门打开——门关闭。
  在面向对象的思想中，操作者变成了调用者，通过调用对象，来实现相关需求。

  面向对象的特点 ：

        面向对象是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序的执行者转化为调用者。 在操作中，应先去寻找封装了所需功能的对象来调用。没   有的话就创建一个封装所需功能的对象。 这样做可以简化开发也可以提高复用性。Java的开发过程就是不断的创建对象，使用对象，指挥对象做事情的。而设计的     过程就是在管理和维护对象之间的关系。

  面向对象的特征：封装(encapsulation)，继承(inheritance)，多态(polymorphism).

 

 二、怎么用面向对象      

     1.类和对象

          使用计算机语言就是不断的描述现实生活中的事物，而Java中描述事物通过类的形式体现，类是具体事物的抽象。生活中描述事物就是描述事物的属性和行  为，如人的年龄、人的身高等属性以及说话吃饭等行为。Java中就是用类class来描述对象的属性和行为。定义一个类就是定义在类中的成员(成员变量(对应属性)和成  员函数(对应行为))。而对象是该类事物实实在在存在的个体。类和对象的关系就如同设计汽车的图纸与汽车的关系，图纸就是类，汽车就是具体的对象。

           定义一个简单的类，并创建它的对象。如：

class Demo
{
public static void main(String[] args)
{
//创建student的一个对象。
Student s=new Studnet();
//给对象的属性赋值。
s.name="小明";
//调用对象的动作
s.speak();
}
}
//定义一个表示学生的类，类中定义学生的姓名、年龄属性，以及学习的行为。
class Student
{
String name;
int age;
public void study(){
System.out.println("在学习");
}
}

  2.成员变量和局部变量

          两者在作用范围和内存中分配不同。成员变量定义在类中，在整个类中都可以被访问；成员变量随着对象的建立而建立，存在于对象所在的堆内存中。并且有    默认的初始化值。

          局部变量只定义在局部范围内，如：函数、语句内等，局部变量存在与栈内存中。作用的范围结束，变量空间会自动释放，并没有默认的初始化值。

   3.匿名对象
          对象的简化。在两种情况下可以使用匿名对象：当对对象仅调用一次时或者将匿名对象作为实际参数进行传递。如果对一个对象的成员进行多次调用时，就不     能用匿名对象了。

 

   4.封装

           封装是面向对象的三大特征之一，是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。就是定义类时把不需要对外提供的属性或方法都隐藏   起来了，对于隐藏起来的属性，类中定义了公共方法对其访问。封装能够将变化隔离，便于使用，提高代码的重用性与安全性。

           而私有(private)是封装最常见的表现形式。private：权限修饰符，用于修饰类中的成员(成员变量、成员函数)，私有的成员只在本类中有效。在以后的   操作中，定义一个类通常将成员变量私有化，对外提供对应的set，get方法对其进行访问。这样做提高了数据的安全性。

    如下图：

    

class Demo
{
public static void main(String[] args)
{
//创建student的一个对象。
Student s=new Student();
//调用访问方法，给对象年龄赋值。
s.setName("小明");
//调用获取方法，获取对象年龄。
s.getName();
}
}
//定义一个表示学生的类，类中定义学生的姓名属性，以及学习的行为。
class Student
{
//将成员属性name私有
private String name;
//提供访问方法
public void setName(String studentName){
name=studentName;
}
//提供获取方法
public String getName(){
return name;
}
public void study(){
System.out.println("在学习");
}
}

  5.构造函数

         构造函数的函数名与类名同名，不用定义返回值类型，不可以写return语句。构造函数是用来给对象进行初始化的。当一个类中没有定义构造函数时，

  系统会默认给该类加入一个空参数的构造函数。当类中自定义了构造函数之后，默认的构造函数就没有了。 构造函数与一般函数除了在写法上有很大不       同，在运行时也有很大不同，构造函数在对象一建立就运行，给对象初始化，而一般方法是对象调用才执行；一个对象建立，构造函数只运行一次，而一   般方法可以被对象调用多次。当分析事物时，如果该事物存在具备一些特性或者行为，那么可以将这些内容定义在构造函数中。          

        构造代码是给对应的对象进行初始化，而构造代码块是给所有对象初始化。当对象一建立，构造代码块就运行，而且优先于构造函数。构造代码块中  定义的是不同对象共性的初始内容。

       例如：

class Demo
{
public static void main(String[] args)
{
//创建student的一个对象。
Student s=new Student("小明");
//调用方法
s.study();
}
}
//定义一个表示学生的类，类中定义学生的姓名属性，以及学习的行为。
class Student
{
//将成员属性name私有
private String name;
//定义构造函数
Student(String name)
{
this.name=name;//this表示初始化的对象，因为成员变量名和局部变量名一样，所以用this加以区分。
System.out.println("我的名字是"+name);
}
//定义构造代码块
{
System.out.println("我是一名学生");
}
//提供访问方法
public void setName(String name){
this.name=name;
}
//提供获取方法
public String getName(){
return name;
}
public void study(){
System.out.println("在学习");
}
}

执行结果



   6.this关键字  

         从上面的程序可以了解this关键字的用法，this代表它所在函数所属对象的引用，就是哪个对象在调用this所在的函数，this就代表哪个对象。当定义类  中功能时，该函数内部要用到调用该函数的对象时，就用this来表示这个对象。

          this语句：是用于构造函数之间进行相互调用的。this语句只能定义在构造函数的第一行，因为初始化要先执行。一般函数不能直接调用构造函数，因  为this语句不能用在一般函数中，只能用在构造函数间。

         例如：     

Student(String name)
{
this.name=name;

}
Student(String name,int age)
{
this(name);
this.age=age;
}

   this关键字有时可以不写，系统会默认为引用所在函数的对象，但当出现成员变量和局部变量同名时，就必须写上this，加以区分。构造函数间调用时要用上this语句。

 7.static关键字

         static：静态修饰符，用于修饰类中的成员(成员变量和成员函数)。当成员被静态修饰后，除了可以被对象调用外，还可以直接被类名调用(类名.静态  成员)。静态成员随着类的加载而加载，也随着类的消失而消失，生命周期长。静态成员先于对象存在。静态成员可以被所有对象共享。由于静态成员可以直接被类名调用，所以静态成员变量又称为类变量。而非静态成员变量成为实例变量。

        实例变量和类变量的区别：类变量随着类的加载而存在于方法区中，实例变量随着对象的建立而存在于堆内存中；类变量生命周期最长，随着类的消  失而消失。实例变量生命周期短，随着对象的消失而消失。

         当对象中出现共享数据时，该数据可以被静态所修饰，对象中的特有数据要定义成非静态存在于堆内存中；当功能内部没有访问到非静态数据(对象的 特有数据)，那么该功能可以定义成静态的。       

         定义静态变量，可以对共享数据进行单独空间的存储，节省内存空间，但生命周期过长；定义静态方法，只可以访问静态成员(非静态方法既可以访问  静态也可以访问非静态)，具有局限性。静态方法中不可以定义this、super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this。

         主函数是静态的。

         静态代码块：随着类的加载而执行，执行一次。并优先于主函数。用于给类进行初始化。

         格式：static{执行语句}

 8.主函数

       一个特殊的函数。作为程序的入口，可以被JVM调用。

    主函数的定义：

        public：代表着该函数访问权限是最大的。

        static：代表主函数随着类的加载就已经存在了。

        void：主函数没有具体的返回值。

        main：不是关键字，但是是一个特殊的单词，可以被JVM识别。

     （String[] arr）：函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

        args：arguments  参数  。唯一可以更改的地方。

 9.对象的初始化过程：

          1.把类名.class文件加载到内存中。

          2.执行该类中的static代码块，如果有的话，给该类进行初始化。

         3.在堆内存中开辟空间，给对象分配内存地址。  

          4.在堆内存中建立对象的特有属性，并进行默认初始化。

          5.对属性进行显示初始化。

          6.对对象进行构造代码块初始化。

          7.对对象进行构造函数初始化。

          8.将内存地址赋给栈内存中的对象变量。

 10.单例设计模式

         设计模式是指解决某一问题最行之有效的方法。Java中有23种设计模式。单例设计模式是经常会用到的一种模式。单例设计模式中一个类在内存中只     存在一个对象，保证了内存中的对象唯一性。单例设计模式有两种格式：懒汉式和饿汉式。

          (1)饿汉式：饿汉式中先建立对象，class类一加载进内存，就创建该类对象。在实际开发中，经常使用饿汉式，保证程序的安全性。

class Single
{
//将构造函数私有化
private Single(){}
//在类中创建本类对象
public static Single s=new Single();
//提供获得该类对象的访问方式
public static Single getInstance(){
return s;
}
}

        (2)懒汉式：方法被调用时，才在内存中创建对象。即对象的延时加载。

class Single
{
//将构造函数私有
private Single(){}
//定义引用变量
public static Single s=null;
//提供获得该类对象的访问方式
public static Single getInstance(){
//创建本类对象
if(s==null)
s=new Single();
return s;
}
}

                      -------------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！
-------