面向对象

    1. 先使用class自定义个类。
    格式：
        class 类名{
            
            事物的公共属性使用成员变量描述；
            
            事物的公共行为功能使用函数描述；
        }

    2. 通过自定义的类创建对象。
            创建对象的格式: 
                类名  变量名 =     new 类名(); 
    3. 访问对象的属性或者调用对象的功能。
        
            访问对象的属性格式：
                    对象.属性名;
            
            调用对象的功能行为：
                    对象.函数名(); 

//车类
class Car{
    
    //事物的公共属性使用成员变量描述
    String name;  //名字的属性

    String    color; //颜色属性
    
    int wheel ;  //轮子数

    //事物的公共行为功能使用函数描述 .  一个方法内部可以直接访问成员变量的。
    public void  run(){
        System.out.println(name+"跑得非常快!!");
    }
}


class Demo1 
{
    public static void main(String[] args) 
    {
        Car    c = new Car(); // 声明了一个Car类型的变量c指向了一个Car对象。
        
        //给对象的属性进行赋值
        c.name = "法拉利";
        c.color = "红色";
        c.wheel = 4 ;
        System.out.println("名字："+ c.name+" 颜色："+ c.color+"  轮子："+ c.wheel);
        
        c.run();  //调用对象的run功能
    }
}

class Car{
    
    //事物的公共属性使用成员变量描述
    String name;  //名字的属性

    String    color; //颜色属性
    
    int wheel ;  //轮子数

    //事物的公共行为功能使用函数描述 .  一个方法内部可以直接访问成员变量的。
    public void  run(){
        System.out.println(name+"跑得非常快!!");
    }
}


class Demo2 
{
    public static void main(String[] args) 
    {
        Car c1 = new Car();
        Car c2 = new Car();
        //c1= null;
        c2 = c1;
        c1.name = "法拉利";  //一个引用类型的变量没有指向任何的对象，而访问了对象 的属性或者是调用了对象的方法。
        c2.name = "保时捷";
        System.out.println("名字:"+ c1.name);  //  
    }
}

//车类
class Car{

    //事物的公共属性使用成员变量描述
    String name;  //描述名字属性

    String color; //描述颜色属性

    int wheel ; //描述车的轮子数属性

    
    //事物的公共行为使用函数描述
    public void run(){
        if(wheel>=4){
            System.out.println(name+wheel+"轮子飞快的跑起来了..");
        }else{
            System.out.println("当前轮子只有"+ wheel+"个，赶快去修理吧！！");
        
        }
    }
}


//修车厂类
class CarFactory{
    
    //公共的属性
    String name;//名字属性

    String address;  //地址属性

    String tel; // 电话属性


    //公共的行为  --- 修车的行为..
    public void repair(Car car){ //定义一个形式参数用于接收破车.
        if(car.wheel<4){
            car.wheel = 4;
            System.out.println("修改了，给钱！！");
        }else{
            System.out.println("非常努力修好了，给多点钱！！");
        }
    }
}


class  Demo4{
    
    public static void main(String[] args) 
    {
        /*
        //创建一个车对象
        Car c = new Car();
        //给车对象分配属性值
        c.name= "宝马";
        c.color = "银色";
        c.wheel = 4;
        //调用车的跑功能
        for(int i = 0 ; i< 100 ; i++){
            c.run();
        }
        c.wheel = 3;
        c.run();


        //创建一个修车厂对象
        CarFactory f = new CarFactory();
        //给修车厂赋值属性值
        f.name = "啊强修车厂";
        f.address = "广州天河棠东东路32号";
        f.tel = "020-110";


        //调用修车厂的修理方法
        f.repair(c);
        c.run();

        需求： 调用一次repair方法。
        */
    
        new CarFactory().repair(new Car());

    }
}

    1.位置的区别：
        成员变量是定义在方法之外，类之内的变量。
        局部变量是定义在方法之内的变量。
    
    2.作用上的区别：
        成员变量的作用是用于描述一个事物的属性.
        局部变量的作用就是用于提供一个变量给方法内部去使用而已。
    
    3. 生命周期的区别：
          成员变量的生命周期是随着对象的创建而创建，随着对象的消失而消失。
          
          局部变量调用到对应的方法时执行到了创建该局部变量语句的时候存在，局部变量
           一旦出了自己的作用域会马上消失。

    4. 初始值的区别： 
            
            成员变量有默认的初始值。 具体的初始值要看变量的数据类型
                int             0
                double        0.0
                float        0.0f
                char        ‘ ‘
                boolean        false
                String        null
            
            局部变量是没有默认的初始值的，要先初始化才能使用。

class People{
    String name;//成员变量
    
    public void eat(){
        int num; //局部变量
        num =3;
        System.out.println(name+"eat "+num+"times every day!");
    } 
}

class Demo1{
    public static void main(String[] args){
        People p = new People();
        p.name="linzi";
        p.eat();
    }
}