Java 学习笔记day 5 (面向对象1)

 面向过程与面向对象都是程序设计的一种风格(思想)

  面向对象的程序设计思想（ Object Oriented Programming），简称OOP
  是以类为单位进行组织,  类:一类问题/分类    String,Math,Arrays,Scanner是一种设计者思维，适合解决复杂问    题。 代码扩展性强、可维护性高。

面向对象可以帮助我们从宏观上把握、从整体上分析整个系统

如果是面向过程的话，将吃西红柿炒鸡蛋拆解成一系列的步骤，每一个步骤就是一个函数。

第一步，买西红柿与鸡蛋；

第二步，用锅铲炒；

第三步，炒完放在盘子里；

第四步，吃。

如果是面向对象的编程方式

可以雇一个人做,,这个人的功能就是买菜,炒菜,做好之后持吃就行,全部事情交给他去做,不用关心怎么做的问题

假如每天都要吃,只需要把这个功能与属性包装成一个对象,需要使用时调用这个对象就好,不用再去写.

类与对象

类与对象
     类:具有相同特征的事物的描述(定义)
        同一类事物的抽象描述
        类就是一个文件,用来静态的定义某一类事物拥有有什么属性与功能
     对象:
        万事万物(大千世界具体存在的东西),皆为对象.
        该类实物具体存在的一个一个个体,是真实存在,也称为实例
类中可以定义:
    变量   属性  名词
    方法   行为  动词
    构造方法
    块    没有名字的代码块
    内部类  在类的内部定义类(嵌套)
变量按照类型分为:
    基本数据类型
    引用数据类型   用类作为类型,String,数组
变量按照位置分:
    成员变量(在类中定义)
        可以使用基本数据类型,也可以使用引用数据类
        java中的变量在使用时都必须初始化
        成员变量可以不对其初始化,系统会默认进行初始化
        成员变量可以在成员方法,构造方法,代码块中使用
    局部变量(在方法中定义)
        局部变量,不会自己初始化
        方法的参数也是局部变量

对象: 是以类为模版,在内存中创建的实际存在的实例

public class Car {
    /*
    定义属性  成员变量   直接在类{  }中定义的内容,称为类的成员
     */
    String name;
    String color;
    int price;
    //....

    /*
    定义方法  成员方法
    方法是类中具有某种功能
     */
    public void run(){
        System.out.println("汽车行驶");
    }
    public void run(int speed){
        System.out.println(name+"汽车行驶的速度为"+speed);
    }

    public void stop(){
        System.out.println("汽车停止");
    }
    
    public static void main(String[] args) {
        /*
          Car car = new Car();
          new Car();   new关键字用来创建对象   以Car类为模版,在内存中会开辟一块独立的空间,用来存储对象信息
              Car()构造方法,每一个类中默认都有一个,方法名字与类名相同
          Car(类型)  car(变量名) 声明一个Car类型的变量
             =  把右边的对象地址赋给左边的变量,用变量在后面的程序中表示内存中的对象
         */
        Car car = new Car();
            car.name = "宝马";
            car.color="black";
            car.price=500000;
            car.run();     //调用方法
            car.run(120);
            car.stop();
        Car bccar= new Car();
            bccar.name = "奔驰";
            bccar.color="black";
            bccar.price=500000;  //调用方法
            bccar.run();
            bccar.run(120);
            bccar.stop();
        /*
        类中的成员变量与成员方法都必须通过创建出来的对象使用
         */
}

构造方法

构造方法名与类名相同 , 且没有返回值,且不需要使用void修饰

作用: 在构造方法中为创建的对象成员初始化赋值

方法的重载

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

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

• 数量不同

• 类型不同

• 顺序不同

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

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

public class Car {
    String name;
    String color;
    int price;
       /*
        Car():类的构造方法,类中没有定义时,会默认有一个无参的构造方法
            构造方法与类名相同
            定义:构造方法与类名相同,且没有返回值,不需要void修饰
            特点:
               类中没有定义时,会默认有一个无参的构造方法,再无参构造方法中为成员变量赋初始值
               还可以定义有参的构造方法,通过有参的构造方法为 成员变量赋初始值
               一旦类中定义了有参构造方法,那么默认的无参构造方法便会失效,
                  如果需要,需要显示定义无参构造方法

            作用:
               用来为新创建的对象中的成员进行初始化
        */
       /*
       方法重载:
           在一个类中,有多个方法名相同,但参数不同的方法,称为方法重载
           如何区分名称相同的多个方法:
               通过参数的个数,类型,顺序,进行区分
           意义:
               做同一件事,但是可以传入不同参数

            方法重载与方法的返回值没有关系
       */
    public Car(){
        System.out.println("无参构造方法1");
        name=null;
        color=null;
        price=0;
    }
    public Car(String n,String c,int p){
        System.out.println("有参构造方法2");
        name=n;
        color=c;
        price=p;
    }
    public Car(String p,int n,String c){
        System.out.println("有参构造方法3");
        name=p;
        color=c;
        price=n;
    }

    public void run(){
        System.out.println("汽车行驶速度为12");
    }
    public void run(int speed){
        System.out.println(name+"汽车行驶的速度为"+speed);
    }

    public void stop(){
        System.out.println("汽车停止");
    }
    public static void main(String[] args) {
        Car bmcar = new Car();
            bmcar.name = "宝马";
            bmcar.color = "black";
            bmcar.price = 500000;
            bmcar.run();
            bmcar.run(120);


        Car bccar=new Car("奔驰","黑色",40000);
        Car dzcar=new Car("大众",2901,"白色");

        System.out.println(bccar.name+"的"+"颜色为:"+bccar.color+",价格为:"+bccar.price);
        System.out.println(dzcar.name);
    }
}

对象与引用

  Java 语言中除基本类型之外的变量类型都称之为引用类型。

  Java 中的对象是通过引用对其操作的

public class Car {
   public String name;
    public String color;
    public int price;

    public Car(){

    }
    public void showInfo(){
        System.out.println(name+":"+color+":"+price);
    }
    public static void main(String[] args) {
        Car car1=new Car();
            car1.name="宝马";
            car1.color="白色";
            car1.price=1000;
            car1.showInfo();

        Car car2=new Car();
            car2.name="奔驰";
            car2.color="白色";
            car2.price=1000;
            car2.showInfo();

        Car car3=new Car();
        car2=car3;
        car3.name="迈巴赫";
        System.out.println(car3.name);
        System.out.println(car2.name);
}

值传递

Java中进行方法调用中传递参数时，参数传递有两种：

● 值传递：(形参数类型是基本数据类型)：方法调用时，实际参数把它的值传递给对应

的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同

的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

● 引用传递：(形参数类型是引用数据类型参数)：也称为传地址。

方法调用时，实际参 数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的 操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法

执行中形式参数的改变将会影响实际参数。

基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。

但是无论是值传递还是引用传递 , 其本质都是传值 , 所以也都统称值传递

址传递:最后输出  奔驰

public class Car {
    public String name;
    public String color;
    public int price;
    public static void main(String[] args) {
        Car car =new Car();
            car.name="宝马";

        Car car  =  new Car();
        Car.test(car);
        System.out.println(car.name);

    }
    public void test(Car car){
        car.name="奔驰";
    }


}

值传递:最后输出10

public class TextValue {
    public static void main(String[] args) {
        int a=10;
        TextValue t=new TextValue();
                  t.test(a);   //基本类型在传参时,将值赋给对应形参x
        System.out.println(a);

    }
    public void test(int x){
        x=20;  //形参x发生变化,不会影响实参a的值
    }
}