黑马程序员 Java基础_4 面向对象-抽象与封装

面向对象，就是把生活中的事物特征抽取出来，作为属性，方法封装到一个类里面。这是一种数据的表现形式，可以更好的对数据进行操作。它主要有三个特征，分别是封装、继承、多态。

一、类与对象的关系

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

对象：这类事物实实在在的个体。

对象是具体的，而类是共性的描述。

需求|：定义一个汽车类，要求设计出汽车的型号（即名字），颜色，轮胎个数，行驶速度，并且让汽车行驶起来（即打印出每个汽车的颜色、轮胎数、速度） 
         并比较两辆汽车之间那个性能更好|：即速度快慢 
思路|： 
    1创建一个构造函数，即一个汽车类，对其的颜色，轮胎数。行书速度，速度，以及其方法，即行驶等进行初始化 
    2在main方法中创建一个汽车对象，并实现其功能 
    3构造一个方法，比较两辆车之间的速度大小 
*/class Car   
{  
    String name;  
    String color;  
    int nums;  
    double speed;  
    Car(String name,String color,int nums,double speed)  
    {  
        this.name = name;  
        this.color = color;  
        nums = 4;  
        this.speed = speed;  
        System.out.println(name + "是一辆" + color + "，轮胎数是：" + nums + "，可以行驶的速度是：" + speed);  
    }  
      
    public void compare(Car c)  
    {  
        if(this.speed > c.speed)  
        {  
            System.out.println(this.name + "行驶得更快。");  
            return;  
        }  
        System.out.println(c.name + "行驶得更快。");  
        return;  
    }  
}  
  
class CarDemo  
{  
    public static void main(String[] args)   
    {  
        Car a = new Car("奔驰","黑色的",4,500);  
        Car b = new Car("宝马","蓝色的",4,600);  
        a.compare(b);  
    }  
}

二、封装

封装是为了防止程序里数据的相互依赖而带来的影响。

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

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

封装有4种权限，他们分别是private,public,protected，还有是default，不写就默认是default，他们对应的关系如下

                       public       protected          default         private

同一个类       ok ok                    ok ok

同一个包 ok ok ok 

子类 ok                  ok

不同包 ok

this关键字

this用于区分局部变量和成员变量同名的情况。

this代表了本类的对象，即代表了它所在函数所属对象的引用，也就是说，哪个对象调用这个函数，this就代表哪个对象。

当定义类中的功能时，该函数内部要用到调用该函数的对象时，这时用this来表示调用这个函数的对象。

static关键字

静态修饰成员变量，成员方法，被对象共享，可以直接用类名调用，静态成员存在于共享区里。静态方法只能访问静态成员。

特点有：

1、随着类的加载而加载

2、被所以对象共享

3、优先于对象存在

4、可以直接用类名调用

什么时候用static

1、当一个方法不需要访问对象是，其中所需的参数都是通过显示参数提供的。

2、一个方法只需要访问类的静态变量。

使用static注意事项：

1、静态方法只能访问静态成员，非静态方法既能访问静态也可以访问非静态

2、静态方法中不可定义this，super等关键字，因为静态优先于对象存在，所以静态方法中不可以出现this

3、主函数是静态的。

static的应用，单例设计模式：

单例的意思就是内存只能存在一个类的对象，那么如何保证对象的唯一性呢，就需要对构造方法私有话，并且提供一个对外的静态方法来获得这个唯一的对象。

单例分两种，饿汉式和懒汉式，饿汉式是随着类的加载就存在对象，而懒汉式是需要用是才创建对象。

饿汉式

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

  
    public static  Single getSingle()  
    {  
        return s;  
    }  
}  
  
class SingleText  
{  
    public static void main(String [] args)  
    {  
        Single s1 = Single.getSingle();  
        Single s2 = Single.getSingle();  
       
        System.out.println(s1==s2);        
    }  
}

懒汉式

class Single   
{  
    private Single(){}  
    private static Single s = null;  
    public static Single getSingle()  
    {  
        if (s==null)   
            s = new Single();  
        return s;  
    }  
}  
  
class SingleText  
{  
    public static void main(String [] args)  
    {  
        Single s1 = Single.getSingle();  
        Single s2 = Single.getSingle();  
         
      System.out.println(s1==s2);  
                
    }  
}