Java基础—面向对象

  java是面对对象的计算机语言，在没接触java以前，此句就耳熟能详。但是具体什么意思，确一窍不通。看了毕老师的视频，如醍醐灌顶。结合老师的讲解和我的了解，写了这篇博客。

  面向对象是相对于面向过程而言的。面向对象，将功能封装进对象，强调的是具备一定功能的对象。面向过程强调的是功能。比如C语言，在编程的时候，思考方式是如何实现指定的功能，而java是去寻找对象，调用对象的功能，若没有建一个，再使用。经典例子：大象放进冰箱、买电脑等。两者的关系：面向过程是面向对象的基础。面向对象的特点：把复杂的事情简单化，人从执行者转变为指挥者。面向对象的特征：封装、继承、多态。java只能单继承，但可以多实现。类和对象的关系：类是java用于描述事物的，而对象是现实中实实在在存在的个体。比如汽车和图纸，图纸相当于类，而汽车相当于对象。

  匿名对象的使用情景：1、当对象方法只调用一次时；2、可以将匿名对象作为实际参数进行传递。

注：私有只是封装的一种方式.

以下是最简单的面向对象编程的结构：

/*
面向对象：对象在java中已实体的形式存在，存储在堆内存中。
 落实到程序：
            1、先定义对象，把功能封装进对象；
            2、创建对象；
            3、通过对象.成员的方式来使用。（成员包括：成员变量和成员方法）
 注：如果成员是静态的，则另一种调用方式：类名.成员

 其他说明：
          在一个类中，有除了参数列表不同外其他都相同的函数，这叫函数的重载现象。
          子父类（实现接口）中，相同的函数，函数体不同叫函数的复写或覆盖，

 静态的特点：随着类的加载而加载，类的消失而消失；
             被所有对象共享；
             存放在方法区（对象存在于堆内存中，局部变量存在于栈内存中）；
             静态只能访问静态，存在的周期长。

 静态代码块、构造函数、一般方法的执行顺序：先执行静态代码块（之间按先后顺序执行，主函数所在类的静态代码块优先与其他类）、
                                           建立对象时执行构造函数、在通过对象调用其他方法。
                                           所以下面代码的打印顺序为：d、e、a、b、c、over；

 由于不确定该类的对象会存在HashSet还是TreeSet的集合里，所以需要复写hashCode、equals方法，
 还要实现Comparable接口，复写compareTo方法。
*/
//描述事物
class Car implements Comparable<Car>
{
    //类中的成员变量被private修饰，一般都要在该类中定义两个方法，设置和获取
    private String color;
    //构造函数的函数名跟类名一致，在一个类中可以有多个构造函数，以重载的方式存在
    Car(String color)
    {
        this.color = color;
        System.out.println("b");
    }
    //静态代码块，随着类的加载而执行。优先于对象存在
    static
    {
        System.out.println("a");
    }
    //操作color变量的设置方法
    public void setColor(String color)
    {
        this.color = color;     
    }
    //获取color值的方法
    public String getColor()
    {
        return color;
    }
    //Car中的成员方法
    public void run()
    {
        System.out.println("c");
    }
    //复写hashCode方法
    public int hashCode()
    {
        return color.hashCode();
    }
    //复写equals方法
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Car))
            throw new ClassCastException("不是Car类型");
        Car c = (Car)obj;
        return this.color.equals(c.color);
    }
    //复写compareTo方法，主要条件相同的时候，需要比较次要条件
    public int compareTo(Car c)
    {
        return this.color.compareTo(c.color);
    }
}
class CarDemo
{
    static
    {
        System.out.println("d");
    }
    //主函数：特殊的函数，能被虚拟机jvm识别调用，程序的入口
    public static void main(String[] args) 
    {
        //建立Car对象
         Car c = new Car("red");
         //调用对象方法
         c.run();
         System.out.println("over");
    }
    static
    {
        System.out.println("e");
    }
}

单例设置模式：饿汉式和懒汉式。

/*
单例设计模式：保证某个类在内存中只有一个对象。
分为饿汉式和懒汉式，懒汉式也称为对象延时加载。
单例设计模式的实现步骤：
                       1、将空参数的构造函数私有化；
                       2、在类的内部创建该类对象；
                       3、对外提供一个获取该类对象的方法。

 注：因为懒汉式对象延时加载，所以需要同步（当一个线程在执行某一块代码时，不允许其他线程参与进来）。
      同步代码的格式：synchronized(对象){同步代码;}这里对象就是锁，只有持有锁才能执行同步代码，

*/
class Single
{
    //饿汉式
    private Single(){}
    Single s = new Single();
       //因为不允许创建该类对象，所以获取该类对象的方法应为静态
    public static Single getSingle()
    {
        return s;
    }
    //懒汉式
    private Single(){}
    Single s = null;
    public static Single getSingle()
    {
        if(s == null)
        {
               //给s赋值有两句语句，为了避免多次给s赋值，所以需要同步，锁是字节码文件
            synchronized(Single.class)
                {
                if(s == null)
                s = new Single();
            }
        }
        return s;
    }
}