Java面向对象的开始（第六天）

Java面向对象的开始（第六天）

面向对象和面向过程的区别：

​ 面向过程：注重的是解决的过程，步骤；

​ 面向对象：是从宏观上的，整体上的设计；

​ 例如：将大象装入冰箱：

​ 用面向过程的思路解决：

​ 分三步：
第一步：打开冰箱门；

​ 第二步：把大象装进去；

​ 第三步：关上冰箱门；

​ 用面向对象的思路解决：

​ 分两类：

​ 第一：设计冰箱类：

​ 开门（）；

​ 关门（）；

​ 第二：设计人类：

​ 操作（）；

Java类

​ 概念：类就是拥有同一类事物的属性与行为的抽象的描述。

​ 类的结构：

​ 1.成员变量：对象属性的描述；

​ 2.方法:对象的行为；

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

​ 4.内部类： 在类体中声明的类；

​ 5.块：代码块。

​ 类的声明格式：

[访问权限修饰符] [修饰符] class 类名 {

}

​ 类的属性：（成员变量）是类的成员，变量，被类所包含。

​ 定义语法：

​ [访问权限修饰符] [修饰符]数据类型 变量名[=值]；

​ 特点：

​ 1.定义在类中,方法体之外；

​ 2.数据类型可以是基本类型/引用类型；

​ 3.成员变量可以不赋值,java会使用默认值自动赋值 引用类型(null) float(0.0)…；

4.在创建对象的时候会从类中复制一份到对象中；

5.作用域为整个类,在类中方法,构造方法,代码块中被使用。
​ **类的行为（方法）：**是类的成员，被类所包含。

​ 声明语法：

​ [访问权限修饰符] [修饰符]数据类型/void（无返回值型）方法名（[参数类型 参数名]）{

​ 语句块

}

​ **类的对象：**就是对类的实例化，是具体的一个事物；

​ 例如：Car baoma = new Car（）；

new Car()：new关键字 + 默认构造方法；

​ 作用是在内存空间中创建一个对象；

Car baoma ：声明一个变量，指向内存空间中的具体对象；

​ 使用baoma变量访问对象中的属性和方法。

示例：

/*
类的声明格式：
[访问权限修饰符] [修饰符] class  类名 {

}

*/
public class Car {
	/*
		成员变量的声明：
		[访问权限修饰符] [修饰符]数据类型	变量名[=值]；
	*/	
           String name;
           float price;
           String color;

           /*
              方法的声明：
              [访问权限修饰符][修饰符] 返回值类型/void 方法名([参数类型 参数名称]){

                    [return 值];
               }
            */
           public void start(){
               System.out.println(name+"汽车启动");
           }

           /*
              在方法、构造方法或者语句块中定义的变量被称为局部变量；
             局部变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）；
             局部变量在使用前必须初始化赋值；
             变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁；
             方法的参数也是属于 局部变量, 在调用时,会为其赋值。
            */
    //创建一个run（）方法，传入参数 String a；
           public void run(String a){
               int speed;
               speed = 10;
               System.out.println("行驶"+speed+a);
           }
	//创建一个stop（）方法
           public void stop(){
                System.out.println("刹车");
           }
    
     		public static void main(String[] args) {

        /*
           创建汽车对象:
              以Car类为模板,
          Car baoma  =  new + Car();  new 关键字+默认构造方法();
                 在内存空间创建一个对象  实际存在的   实例化对象
           Car baoma 以Car类作为类型 声明一个变量 指向内存空间中的具体的对象
               使用baoma变量访问对象中属性,方法

               通过类可以创建无数个对象
         */
                
          //创建一个以Car为模板的baoma对象
              Car baoma  = new Car();
                  baoma.name = "x5";
                  baoma.price = 600000;
                  baoma.color = "红色";
                
		  //创建一个以Car为模板的benchi对象
              Car benchi = new Car();
                  benchi.name = "GTR";
                  benchi.price = 700000;
                  benchi.color = "黑色";

                System.out.println(baoma.name);
                System.out.println(baoma.price);
                System.out.println(baoma.color);

                 baoma.start();//成员方法必须通过对象调用

}

构造方法

概念与作用：

​ 1.是定义在Java类中一个用来创建对象的方法；

​ 2.构造方法与类名相同，没有返回值，也不需要用void修饰；

​ 3.一个类中也可以拥有多个构造方法（方法的重载）；

​ 4.如果类中没有显示声明构造方法，类中也会默认产生一个没有参数的构造方法；

​ 5.一旦类中定义了新的构造方法，则默认的无参构造的方法将会失效，但还是建议将无参的构造方法显示出来；

方法的重载：

​ 指在同一个类中定义相同名字的多个方法，但其参数不同

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

​ 1.数量不同

​ 2.类型不同

​ 3.顺序不同

示例：

public class Person {
       /*
          成员变量
        */
       String name;
       int age;
       
       /*
          构造方法
        */
       public  Person(){
           System.out.println("Person构造方法1");
       }
       
		public Person(String n){
              name = n;
              System.out.println("Person构造方法2");
       }

       public Person(String n,int a){
              name = n;
              age = a;
              System.out.println("Person构造方法3");
       }

       /*
        成员方法进行方法的重载
        构成方法重载的条件
        在同一个类中,有多个方法名相同,且参数不同.
            参数不同具体表现:
             个数不同
             类型不同
             顺序不同
        */
       public void eat(){

       }
       public void eat(int a){

       }
       public void eat(int a,int b){

       }
       public void eat(String a,int b){

       }
       
}