java_面向对象

创建一个对象

package Day3.d0;

/**
 * 定义一个类
 * 创建多个对象默认人的各种行为
 */
public class d0 {
//    静态特征 成员变量 名称  field
    String name;
    int age;

//    动态行为  成员方法  动词  method
    public  void eat(){
        System.out.println("人是铁饭是钢一顿不吃饿得慌");
    }
    public void work(){
        System.out.println("好好学习天天向上");
    }

    public void rest(String site){
        System.out.println(name+"在"+site+"休息");
    }


}

package Day3.d0;

public class Testd0 {
    public static void main(String[] args) {
        d0 k1 = new d0();
        k1.name = "张三";
        k1.age = 23;

        k1.eat();
        k1.work();
        k1.rest("工地");

    }
}

结果

人是铁饭是钢一顿不吃饿得慌
好好学习天天向上
张三在工地休息

成员变量有默认值，可以不赋值

此时内存中发生了什么

构造方法极其重载

1、构造方法

我们每次new，都是一个构造方法

package com.xjy;

public class Computer {
    private String brand;//品牌
    private double size;//尺寸

    public Computer(){
        System.out.println("这里是构造方法，也叫构造器，和类同名不写返回值，完成创建对象的初始化操作");
        System.out.println("如果一个构造方法也没有写，那么默认有一个无参数的构造方法");
    }
    public Computer(String brand,double size){
        this.brand=brand;
        this.size=size;
//        this只能加到成员变量上
    }

    public  void show(){
        System.out.println(size+"寸的"+brand);
    }
    public int add(int num1,int num2){//num1和num2是局部变量
        return num1+num2;
    }

    public int sub(int num1,int num2){
        return num1-num2;
    }

    public static void main(String[] args) {
       /* Computer computer = new Computer();//这里的new Computer()就是构造方法
        computer.brand="lianxiang";
        computer.size=4.5;//但是这里一个个赋值很麻烦 我们可以再构造的时候直接将方法传过去*/

        Computer computer = new Computer("lianxiang",4.5);//但是这里就需要写一个带参数的构造方法
        computer.show();//4.5寸的lianxiang

    }
}

2、对象数组

package com.xjy;

public class ObjectArray {
    public static void main(String[] args) {
        //基本数据类型的数组
        int[] arr;
        arr = new int[4];
        arr[0]=0;
        arr[1]=1;
        arr[2]=2;
        arr[3]=3;
        for (int x:arr) {
            System.out.print(x+",");
        }
        System.out.println();
        //引用类型的数组
        Computer[] arr2=new Computer[4];
        arr2[0]=new Computer("yinter",4.4);
        arr2[1]=new Computer("aierlan",10.2);
        arr2[2]=new Computer("jinshidun",2.4);
        arr2[3]=new Computer("ccdisd",8.9);

        for (Computer x:arr2) {
            x.show();
           /* 4.4寸的yinter
            10.2寸的aierlan
            2.4寸的jinshidun
            8.9寸的ccdisd*/
        }
    }

}

此时的电脑内存图：
引用类型默认值为null

3、关于值传递

4、关于引用传递

第一回合

package com.xjy;

public class Change {
    public static void main(String[] args) {
        P p = new P();
        p.x=10;
        p.y=20;
        System.out.println("交换前"+"x="+p.x+",y="+ p.y);
        swap(p.x, p.y);
        System.out.println("交换后"+"x="+p.x+",y="+ p.y);
    }

    /**
     * 交换两个值
     */
    public static void swap(int num1,int num2){
        int temp;
        temp=num1;
        num1=num2;
        num2=temp;
    }
}

结果：

交换前x=10,y=20
交换后x=10,y=20

可见，此时的值并没有成功交换，因为它传入的p.x是一个确定的值，而不是地址，所以是复制了一份传给了swap的形参

第二回合

package com.xjy;

public class Change {
    public static void main(String[] args) {
        P p = new P();
        p.x=10;
        p.y=20;
        System.out.println("交换前"+"x="+p.x+",y="+ p.y);
        swap(p);
        System.out.println("交换后"+"x="+p.x+",y="+ p.y);
    }

    /**
     * 交换两个值
     */
    public static void swap(P p){
        int temp;
        temp=p.x;
        p.x=p.y;
        p.y=temp;
    }
}

结果：

交换前x=10,y=20
交换后x=20,y=10

经过改良，传入的是p对象，是一个引用类型，传入的是地址，所以在本质上也改变了。
注意此时swap的形参是P p

this关键字

①每创建一个对象就会产生一个this，this只能访问成员变量不能访问局部变量

②还可以在构造函数的时候减少代码量，且只能放在第一条语句

package com.xjy;

public class P {

    int x;
    int y;
    int z;

    public P(){
        
    }
    public P(int x,int y){
        this.x=x;
        this.y=y;
    }
    public P(int x,int y,int z){
    	this(x,y);
        this.z=z;
    }
   

}

③调用成员方法 this.show(),当然this在这里可以省略