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

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

一、引言

看了毕老师的java基础视频，说实话真的讲的很清晰、很透彻、也很有条理性。毕老师的视频的不一样之处在于，他会告诉你为什么这样做，带你正确去思考问题，而不像其他的一些培训讲师，只是单纯的告诉你怎么去用，一旦一段时间你不学，你就会忘记。而学了毕老师的视频后，我觉得我是真的入门java了，以前虽说也写了很多java程序，却也只是照猫画虎。决心来参加黑马的培训，起初对他的入学流程很反感，又是自荐信又是博客的，但现在想想，写写博客就相当于记记笔记，如果你练这点都不愿意做了，就算去了黑马，凭什么就说你能学的好？所以，我不但要写，而写要写的很好，认真仔细的对待每一个细节！

二、理解面向对象

2.1 面向对象与面向过程的区别

其实，面向对象是与面向过程相对应的。一般的编程语言（c语言等）是把程序当作一个不可分割的语言段整体，其中的子函数和主函数是调用关系，子函数或主函数的变化都会引起程序的不稳定；面向对象是将程序分割乘不同的类，子函数可以是类，主函数也可以是类，然后再对类进行封装并定义各个类的级别和访问权限以确保程序的稳定性。
在Java的开发过程，其实就是不断的创建对象，使用对象，指挥对象做事情。设计的过程，其实就是在管理和维护对象之间的关系。面向对象的三大特性：封装、继承、多态。

2.2 类和对象的关系

类：就是对现实生活中事物的描述

对象：就是这类事物，实实在在存在的个体

2.3 类的成员

在类中定义其实都称之为成员。成员有两种：

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

b）成员函数：其实对应的就是事物的行为。
例：

public class Person {  
       private String name;//成员属性-姓名  
       private int age;//成员属性-年龄  

       //成员方法  
       public void sayHello(){  
                       System.out.println("Hello,黑马程序员训练营！");  
       }  

如上面的代码，我们在Person类中定义了，name和age两个成员变量，和一个sayHello()的成员方法。而我们要调用sayHello方法，必须先建立Person类的实例p，然后再通过p.sayHello的方式进行调用。

从上面可以知道，类中可以定义成员变量，而在成员方法中其实也可以定义局部变量，那么成员变量与局部变量有什么区别呢？

成员变量：

a) 成员变量定义在类中，在整个类中都可以被访问。

b) 成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

c) 成员变量有默认初始化值。

局部变量：

a) 局部变量只定义在局部范围内，如：函数内，语句内等。

b) 局部变量存在于栈内存中。

c) 作用的范围结束，变量空间会自动释放。

d) 局部变量没有默认初始化值。

2.4 对象的产生

在main方法中的重点就是产生对象，对象的产生格式是：

类名称对象名称 = null ; ==> 声明对象

对象名称 = new 类名称(); ==> 实例化对象

new就表示要开辟新的内存空间。

2.5 构造函数

用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。特点：

1）该函数的名称和所在类的名称相同。

2）不需要定义返回值类型。

3）该函数没有具体的返回值。

**记住：所有对象创建时，都需要初始化才可以使用。
要想学好JAVA，首先你必须清楚每行代码在执行的过程中，对应内存空间的的分布情况。那么当我们执行：Person p = new Person ()这行代码来创建一个对象时，在内存中做了什么事情？**
1）先将硬盘上指定位置的Person.class文件加载进内存。

2）执行main方法时，在栈内存中开辟了main方法的空间(压栈-进栈)，然后在main方法的栈区分配了一个变量p。

3）在堆内存中开辟一个实体空间，分配了一个内存首地址值。new

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

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

6）进行实体的构造代码块初始化。

7）调用该实体对应的构造函数，进行构造函数初始化。

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

三、封装

3.1 何为封装

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：将变化隔离；便于使用；提高重用性；安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。

public class Person {  
    private String name;// 成员属性-姓名  
    private int age;// 成员属性-年龄  

    public Person() {  
        this.name = "黑马";  
        this.age = 5;  
    }  

    // 成员方法  
    public void sayHello() {  
        System.out.println("Hello,黑马程序员训练营！");  
    }  

    // 以下定义属性的get和set方法  
    // 将属性私有化后，就只能通过get和set方法来获取或改变属性的值。  
    public void setName(String name) {  
        this.name = name;  
    }  

    public void setAge(int age) {  
        this.age = age;  
    }  

    public String getName() {  

        return name;  
    }  

    public int getAge() {  
        return age;  
    }  

    public static void main(String[] args) {  
        Person p = new Person();  
        //在外界仍然可以通过get和set方法来获取和改变私有属性.  
        System.out.println(p.getName());  

    }  
}  

看完上面的代码，也许你就会有疑问了。不是说将类的属性设置为私有的，是为了不让人访问吗？而我这里仍然还是可以通过get和set方法来获取甚至修改其私有属性，这跟将其设置为公有的又有什么区别呢？其实，我们可以这样想，即便是私有的东西，有时候也会拿出来给人看看，是吧？所以这里就有了get和set方法暴露对外，事实上我们可以在set和get方法前面加上很多诸如权限控制的代码，这样只有符合要求的人才可以访问和修改私有属性。而我们通常在写程序时，只是一键生成了get和set方法，其实忽略了其真正的本意。

3.2 this关键字

this:代表对象。就是所在函数所属对象的引用。

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

this 还可以用于构造函数间的调用。

调用格式：this(实际参数)；

this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；

this对象后面跟上 () 调用的是本类中的对应参数的构造函数。

注意：用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。

3.3 static关键字

static关键字是一个修饰符，用于修饰成员(成员变量和成员函数)。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。

static特点：
1）随着类的加载而加载。也就说：静态会随着类的消失而消失。说明它的生命周期最长。

2）优先于的对象存在。明确一点：静态是先存在。对象是后存在的。

3）被所有对象所共享
4）可以直接被类名所调用。

实例变量和类变量的区别：
1）存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2）生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
1）静态方法只能访问静态成员。非静态方法既可以访问静态也可以访问非静态。
2）静态方法中不可以定义this，super关键字。因为静态优先于对象存在。所以静态方法中不可以出现this。
3）主函数是静态的。

静态有利有弊
利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。 可以直接被类名调用。
弊端：生命周期过长。访问出现局限性。(静态虽好，只能访问静态。)

class Person  
{  
    String name;//成员变量，实例变量。  
    static String country = "CN";//静态的成员变量，类变量。  
    public static void show()  
    {  
        System.out.println("::::");  
        this.haha();  
    }  
    public void haha()  
    {  
    }  
}  

class  StaticDemo  
{  
    public static void main(String[] args)   
    {  
        Person p = new Person();  
        //p.name = "zhangsan";  
        //p.show();  

        //System.out.println(p.country);  

        //System.out.println(Person.country);  

        Person.show();  
    }  
}  

3.4 静态代码块

格式：
static
{
静态代码块中的执行语句。
}

特点：随着类的加载而执行，只执行一次,并优先于主函数。用于给类进行初始化的。

这里注意与构造代码块进行区别，构造代码块的格式：

{

构造代码块语句。

}

特点：构造代码块随着对象的创建而执行，其主要作用是给所有的对象进行一些公共的初始化。

什么使用静态？

要从两方面下手：因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量(类变量)呢？
当对象中出现共享数据时，该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数呢？

当功能内部没有访问到肺静态数据(对象的特有数据)，
那么该功能可以定义成静态的。

3.5 main函数的解析

相信在写java程序时，你可能写过无数次的public static void main(String[] args)，但你真的就知道，每个修饰符的含义以及为什么要用它来修饰吗？

主函数的定义：
public：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
（String[] args）:函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String[0];

3.6 单例模式

设计模式：解决某一类问题最行之有效的方法。而单例模式则，解决一个类在内存只存在一个对象。

想要保证对象唯一。
1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这三部怎么用代码体现呢？
1）将构造函数私有化。
2）在类中创建一个本类对象。
3）提供一个方法可以获取到该对象。

class SingleDemo   
{  
 public static void main(String[] args)   
 {  
   Student s1 = Student.getStudent();//获取一个Student对象  
   Student s2 = Student.getStudent();获取另一个Student对象  
   System.out.println(s1==s2);//判断两个对象是否为同一对象  
 }  
}  


class Student  
{  
 private int age;  

 private static Student s = new Student();//持有自身对象的静态引用，确保只有一份实例  
 private Student(){}//将构造器私有化  
 public static Student getStudent()//提供公有方法，获取对象的实例  
 {  
  return s;  
 }  

//以下为对象的get和set方法   
 public void setAge(int age)  
 {  
  this.age = age;  
 }  
 public int getAge()  
 {  
  return age;  
 }  
}  

补充说明：实例变量、静态变量、构造代码块、构造函数、静态代码块，初始化顺序问题！

public class InialTest {  

    public static void main(String[] args) {  
        Son s = new Son();  
    }  
}  

class Father {  
    private Info info1 = new Info("父类非静态变量初始化");  
    private static Info info2 = new Info("父类静态变量初始化");  

    Father() {  
        System.out.println("父类构造函数执行");  
    }  

    static {  
        Info info3 = new Info("父类静态代码块执行");  
    }  
    {  
        Info info4 = new Info("父类构造代码块执行");  
    }  
}  

class Son extends Father {  

    private Info info1 = new Info("子类非静态变量初始化");  
    private static Info info2 = new Info("子类静态变量初始化");  

    Son() {  
        System.out.println("子类构造函数执行");  
    }  

    static {  
        Info info3 = new Info("子类静态代码块执行");  
    }  
    {  
        Info info4 = new Info("子类构造代码块执行");  
    }  
}  

class Info {  
    Info(String message) {  
        System.out.println(message);  
    }  
}  

通过运行结果分析，我们可以得到以下的一些结论：

父类优先于子类，静态的优先于非静态的，非静态实例变量的初始化在构造代码块执行之前，而构造代码块优先于构造函数！
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-