面向过程和面向对象的设计思路

面向过程：POP

1. 分析出解决问题所需要的步骤，然后把步骤一步一步实现；
2. 面向过程直接关注流程；

面向对象：OOP

1. 以分类的方式进行思考和解决问题；
2. 面向对象先对整体关系作出分类，然后根据不同的类深入细节的处理；
3. 面向对象的思想符合人类的认知习惯；

面向对象和面向过程都是语言设计思想

案例：把大象装进冰箱

面向过程：关注于具体的流程，一步一步实现解决问题

1. 开门();
2. 装大象();
3. 关门();

    面向对象：

先设计，对现实中客观事物进行分类，创建出类（在类中定义功能），创建出具体的对象，

让对象去做具体的事情；

    类是对象现实事物的抽象；

    冰箱类{

                开门();

                关门();

                装大象();

    }

                大象类{

    }

              

       

    

Java类

什么是类：类是对现实事物的抽象；

先有对象后有类；

人          人类（概念）

张三        对象（具体的一个人）

类的结构：成员变量：事物属性的描述；

          方法    ：事物的行为；

          构造方法：用于创建对象；

          内部类  ：即在类体中声明的类；

          块      ：一段没有名称的代码块；

      

Java类的定义（案例Car）

1.发现类：

      类的声明格式为：

          [访问权限修饰符] [修饰符] class Car{

}

                访问修饰符有两种：public，无（默认）

                修饰符：final，abstract

                关键字class用来定义一个类；

2.发现类的共有属性（成员变量）

               public class Car{ //成员变量定义

                             String name; //名称

                             String color; // 颜色

                             float price;//价格

                    }

声明成员变量的格式为：

[访问权限修饰符] [修饰符] type attr_name

[=defaultValue]

       3.发现类的方法

public class Car{ //成员变量定义

          String name; //名称

          String color; // 颜色

          float price;//价格

方法声明格式为:

 [访问权限修饰符] [修饰符]/ void start(){

            System.out.println("汽车启动");

            [return 返回值;]

                  }

}

        

具体代码：

package day1;
/*
1.发现类
       汽车类
       public修饰的类，类名必须与文件名一致;
       [访问权限修饰符][修饰符] class 类{
       }
 */

public class Car {

    /*
    2.定义类的成员变量(属性) 名词, 成员:类的成员，在类中定义
     */

    String name;
    float price;
    String color;

    /*
    3.定义类的成员方法(行为/功能) 动词
     */

    public void run(){
        System.out.println(name+price+color+"汽车行驶");
    }
    public void stop(){
        System.out.println(name+"汽车停止");
    }
}

package day1;

public class TestCar {
    public static void main(String[] args) {

 /*
 对象:具体存在的客观事物，可以拿来使用;

 1、new Car();  new 以Car类为模板 在内存中创建对象，
    Car()构造方法（默认有一个构造方法，方法名与类名相同）
    Car bm/bc 声明了一个Car类型的变量
    = 将创建的对象赋给了左边的变量
    bm 表示一个具体存在的对象，可以使用
    bm.name 表示属性
*/

        Car bm = new Car();
            bm.name = "宝马";
            bm.color = "黑色";
            bm.price = 300000;
            bm.run();
        Car bc = new Car();
            bc.name = "奔驰";
            bc.color = "白色";
            bc.price = 400000;
            bc.run();

    }
}

运行结果：

             宝马300000.0黑色汽车行驶

             奔驰400000.0白色汽车行驶

• Java对象

      类是一类事物的抽象概念，是一个模板；

对象：对象是类的一个实例，是以类为模板在内存中创建的实际存在的实例。 

      创建对象的过程也叫做实例化对象；

• 对象的创建和使用

        Car x1 = new Car();

        Car x1:使用Car类作为声明一个变量x1；

        new Car():使用new + Car类构造方法创建对象；

        = ：将右边创建的对象地址赋给左边的x1变量，使用x1变量访问对象中的成员变量和成员方法；

        同一类的每个对象有不同的成员变量存储空间；

        同一类的每个对象共享该类的方法；

• 变量分类（按位置变量分）

        成员变量：定义在类中，方法体之外的变量；

            成员变量可以使用java语言中任何一种数据类型（包括基本数据类型和引用数据类型） ；

            定义成员变量是可以初始化，不初始化时，java会用默认值为其初始化；

            引用类型默认值是null，整数是0，浮点是0.0，boolean是false，char是‘ ’；

            成员变量在创建对象的时候会从类中复制一份到对象中；

成员变量可以被类中方法、构造方法和特定类的语句块访问；

成员变量的作用范围为整个类体；

        局部变量：

            在方法、构造方法或者语句块中定义的变量被称为局部变量。

局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。

局部变量在使用前必须初始化赋值。

变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

• 方法分类

        成员方法：定义在类中，没有被static修饰的，通过对象调用；

                  语法格式：

修饰符 返回值类型 方法名 ( 参数列表) {

方法体语句；

[return 返回值]

}

        构造方法：用来初始化对象的方法；

• 构造方法

       定义:构造方法名与类名相同，且没有返回值，且不需要使用void修饰；

       作用：在构造方法中为创建的对象初始化赋值；

       在创建一个对象的时候，至少要调用一个构造方法。

       每个类都有构造方法。如果没有显式地为类定义构造方法，java将会为该类提供一个默认的构造方法，但是只要在一个java类中定义了一个构造方法后，默认的无参构造方法即失效。

       

• 方法的重载

        方法的重载是指同一个类中具有相同的名字，但参数不同的多个方法。

        参数不同（可以有三方面的不同）

            数量不同；

            类型不同；

            顺序不同；

        调用时，会根据不同的参数表选择对应的方法。

        注意：方法的重载跟方法的返回值类型没有任何关系。

package day2;

/*
    构造方法：
       作用：用来初始化新创建的对象
       特点：构造方法名与类名相同，没有返回值，且不需要void修饰
            每个类中都至少有一个构造方法，也可以定义多个，每创建一个对象时，至少调用一个构造方法
            如果类中无构造方法，默认会提供一个无参的，一旦定义有参的构造方法，默认的无效
 */

public class Car {

    String name;
    float price;
    String color;

    //在无参构造方法在为新建的对象用默认值初始化赋值
    public Car() {
        System.out.println("Car类无参构造方法");
    }

    //定义了有参的构造方法，为新建对象初始化赋值
    public Car(String n,float p,String c) {
        System.out.println("有三个参数的构造方法");
        name = n;
        price = p;
        color = c;
    }

    public Car(String n,float p) {
        System.out.println("有两个参数的构造方法");
        name = n;
        price = p;
    }

    /*
    方法重载：在同一个类中，有多个方法名相同，但参数不同的方法
    参数：个数
         类型
         顺序
    方法重载与返回值无关
    成员方法也可以重载
     */

    public void run(int b){
        System.out.println(name+price+color+"汽车行驶");
    }
    public void stop(){
        System.out.println(name+"汽车停止");
    }

    public void text(){}
    public void text(int a){}
    public void text(int a,int b){
        System.out.println("int a,int b");
    }
    public void text(int a,float b){
        System.out.println("int a,float b");
    }
}

package day2;

public class TestCar {
    public static void main(String[] args) { 

        /*
          new Car();
              Car();  构造方法，每一个类中默认有一个构造方法
         */

        Car bm = new Car();
            bm.name = "宝马";
            bm.color = "黑色";
            bm.price = 300000;
            bm.run(100);

        Car bc = new Car();
            bc.name = "奔驰";
            bc.color = "白色";
            bc.price = 400000;
            bc.run(200);

            Car dz = new Car("大众",200000,"黑色");
        System.out.println(dz.name);
        System.out.println(dz.price);
        System.out.println(dz.color);
             dz.run(100);

        Car ms = new Car("马赛",500000);
        System.out.println(ms.name);
        ms.run(100);

        ms.text(100,100);


        new Car("aa",200);
    }
}

运行结果：

         

Car类无参构造方法

宝马300000.0黑色汽车行驶

Car类无参构造方法

奔驰400000.0白色汽车行驶

有三个参数的构造方法

大众

200000.0

黑色

大众200000.0黑色汽车行驶

有两个参数的构造方法

马赛

马赛500000.0null汽车行驶

int a,int b

有两个参数的构造方法