Java笔记----4. 面向对象（基本概念）

一. 类和对象

1. 定义类：

[修饰符] class 类名
{
    0~N个构造器定义
    0~N个Field
    0~N个方法
}

修饰符：public, final, abstract或完全省略

定义构造器

[修饰符] 构造器名(形参列表)
{...}

修饰符：public, protected, private 或完全省略

定义Field

[修饰符] Field类型 Field名 [=默认值]

修饰符：public, protected, private, static, final 或完全省略

定义方法

[修饰符] 方法返回值类型 方法名(形参列表)
{...}

修饰符：public, protected, private, static, final, abstranct 或完全省略

2. 对象的产生与使用

定义一个类

public class Person
{
    // 下面定义了两个成员变量
    public String name;
    public int age;
    // 下面定义了一个say方法
    public void say(String content)
    {
        System.out.println(content);
    }
}

使用类

// 使用Peron类定义一个Person类型的变量
Person p;

// 通过new关键字调用Person类的构造器，返回一个Person实例，
// 将该Person实例赋给p变量。
p = new Person();

// 访问p的name实例变量，直接为该变量赋值。
p.name = "李刚";

// 调用p的say方法，声明say()方法时定义了一个形参，
// 调用该方法必须为形参指定一个值
p.say("Java语言很简单，学习很容易！");

// 直接输出p的name实例变量，将输出 李刚
System.out.println(p.name);

// 将p变量的值赋值给p2变量
Person p2 = p;

二. 方法详解

1. 方法的参数传递机制
java的参数传递方式只有一种： 值传递

public class PrimitiveTransferTest
{
    public static void swap(int a , int b)
    {
        // 下面三行代码实现a、b变量的值交换。
        // 定义一个临时变量来保存a变量的值
        int tmp = a;
        // 把b的值赋给a
        a = b;
        // 把临时变量tmp的值赋给a
        b = tmp;
        System.out.println("swap方法里，a的值是"
            + a + "；b的值是" + b);
    }

    public static void main(String[] args)
    {
        int a = 6;
        int b = 9;

        swap(a , b);
        System.out.println("交换结束后，变量a的值是"
            + a + "；变量b的值是" + b);
    }
}

可以看到交换后原来的a， b值没有变，如果参数是类呢？如下：

class DataWrap
{
    int a;
    int b;
}

public class ReferenceTransferTest
{
    public static void swap(DataWrap dw)
    {
        // 下面三行代码实现dw的a、b两个成员变量的值交换。
        // 定义一个临时变量来保存dw对象的a成员变量的值
        int tmp = dw.a;
        // 把dw对象的b成员变量值赋给a成员变量
        dw.a = dw.b;
        // 把临时变量tmp的值赋给dw对象的b成员变量
        dw.b = tmp;
        System.out.println("swap方法里，a成员变量的值是"
            + dw.a + "；b成员变量的值是" + dw.b);
        // 把dw直接赋为null，让它不再指向任何有效地址。
        dw = null;
    }

    public static void main(String[] args)
    {
        DataWrap dw = new DataWrap();
        dw.a = 6;
        dw.b = 9;
        swap(dw);
        System.out.println("交换结束后，a成员变量的值是"
            + dw.a + "；b成员变量的值是" + dw.b);
    }
}

交换后a, b值都变了。

因为类是引用类型，指向类里的是地址，而main里的dw和swap里的dw都指向同一个对象，如下图：