Java面向对象(一)

1. 面向对象

1.1 类中的成员变量与局部变量

类中属性（或成员变量）的声明和使用
成员变量 vs 局部变量

相同点：

1.声明变量的结构：数据类型 变量名=变量值
2.先声明，后使用
3.都有对应的作用域

不同点：

1.类中声明的位置不同

成员变量：直接在类中声明
局部变量：方法的形参，方法的内部，构造器的内部，构造器的形参（数组，类，接口）

2.权限修饰符的使用

成员变量声明前可以使用权限修饰符，而局部变量不能使用

3.针对变量值的说明

成员变量可以不手动初始化，系统会自动初始化，而局部变量必须手动初始化

4.内存中加载的位置不同

局部变量：声明在栈空间中
成员变量：声明在堆空间中

1.2 类中方法的声明和使用

方法声明的格式：

权限修饰符 返回值类型 方法名（形参列表）{
//方法体
}

细节说明：

权限修饰符：指明所修饰的结构可以被调用的范围的大小
返回值类型：具体的数值类型或void(没有返回值)
方法名：属于标识符，声明时满足标识符的命名规则规范
形参列表：根据需要提供形参列表，只需提供“数据类型 形参名”
方法体：真正体现方法功能的部分

1.2.1 方法的重载

同一个类中，相同的方法名，且方法的参数列表不同的方法之间构成方法的重载。

/*
 *同一个类，相同的方法名，参数列表不同
 * 与返回值类型无关
 */
public class OverLoadDemo {
    public void getSum(int i, int j) {
        System.out.println(i + j);
    }

    public void getSum(double d1, double d2) {
        System.out.println(d1 + d2);
    }

    public void getSum(int i, int j, int k) {
        System.out.println(i + j + k);
    }

    public String getSum(int i, String j) {
        return i + j;
    }

    public void method(int i, String s) {
        System.out.println(i + s);
    }
}

1.2.2 可变个数形参方法

public class JavaDemo01 {
    public static void main(String[] args) {
        JavaDemo01 test = new JavaDemo01();
        test.method();//可变个数形参最少参数为0个
        test.method("hello", "java");
    }

    public void method(int i) {
        System.out.println(i);
    }

    public void method(String s) {
        System.out.println(s);
    }

    public void method(String... strs) {
        System.out.println("可变参数");
        System.out.println(strs);
//        for (String str : strs) {
//            System.out.println(str);
//        }
        //可变形参可以向数组一样遍历出其中的每个参数
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
    }
    // 由于底层可变形参相当于将是将参数定义在一个数组中，所以不能同时存在方法名相同且类型相同的可变参数和数组
//    public void method(String[] args){
//
//    }

    // 当同时存在位置参数和可变个数的参数，可变个数的参数必须放在最后
    public void method(int i, String... strs) {
        System.out.println(i);
        for (String str : strs) {
            System.out.println(str);
        }
    }
}

1.2.3 方法参数的传递

public class JavaDemo01 {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        JavaDemo01 swa = new JavaDemo01();
        swa.swap(i, j);
        // 此时i，j没有交换值，因为电泳swap()方法时，是在使用类中的成换变量i,j的值
        // 赋值给了swap()方法的形参
        System.out.println("i= " + i + ", j= " + j); // i= 10, j= 20

        Data data = new Data();
        swa.swap(data);
        // 此时进行了交换
        System.out.println("m= "+data.m+",m= "+data.n);

    }

    public void swap(int i, int j) {
        int temp = i;
        i = j;
        j = temp;
    }

    public void swap(Data data) {
        int temp = data.m;
        data.m = data.n;
        data.n = temp;

    }
}

class Data {
    int m = 10;
    int n = 20;
}

1.3 匿名对象的使用

使用格式：

(1) new 类名();
(2) new 类名().实例变量;
(3) new 类名().实例方法;

public class PhoneTest {
    public static void main(String[] args) {
        PhoneFactory factory = new PhoneFactory();

        Phone phone1 = new Phone();
        phone1.name = "xxxxx";
        phone1.price = 5399;

        factory.usePhone(phone1);

//        匿名对象特点：
//        1、由于我们没有记录堆内存对象的地址值，所以只能用一次，再次使用就找不到了
//        2、匿名对象的好处就是使用完毕就是垃圾，可以在垃圾回收器空闲时回收，节省内存空间
        // 匿名对象的使用
        factory.usePhone(new Phone());
        System.out.println(new Phone().name);
        new Phone().show();
    }
}

class PhoneFactory {
    public void usePhone(Phone phone) {
        phone.show();
        phone.call();
        phone.sendSMS();
    }
}


class Phone {
    String name;
    int price;

    public void call() {
        System.out.println("使用手机通话");
    }

    public void sendSMS() {
        System.out.println("使用手机发短信");
    }

    public void show() {
        System.out.println("name= " + name + ", price= " + price);
    }
}

1.4 封装

封装概述

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：

隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性。

封装原则：

将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。

封装运用的一个案例：

public class FunctionDemo {

    public static void main(String[] args) {
        Student s = new Student();
//        s.age = -25;
        s.show(); // 姓名：null  年龄：-25 不合理 此时可以把年龄私有化，对年龄赋值增加合理性的判断逻辑

        s.setAge(-25); // 所填写年龄不正确!
    }

}

class Student {
    String name;
    //    int age;
    private int age;

    public void show() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
    }

    public void setAge(int aa) {
        if (aa > 0) {
            age = aa;
        } else {
            System.out.println("所填写年龄不正确!");
        }
    }
}

1.5 private & this & static 关键词

1.5.1 private关键词

private关键字：

是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。

private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法

一个标准的案例的使用

class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

1.5.2 this关键词

this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
什么时候使用this呢?
局部变量隐藏成员变量

1.5.3 static 关键字

可以修饰成员变量和成员方法

static关键字特点
随着类的加载而加载
优先于对象存在
被类的所有对象共享
这也是我们判断是否使用静态关键字的条件
可以通过类名调用

static关键字注意事项

在静态方法中是没有this关键字的,因为静态是随着类的加载而加载，this是随着对象的创建而存在
静态方法只能访问静态的成员变量和静态的成员方法

1.5.3.1 静态变量和成员变量的区别

所属不同

静态变量属于类，所以也称为为类变量
成员变量属于对象，所以也称为实例变量(对象变量)

内存中位置不同
静态变量存储于方法区的静态区
成员变量存储于堆内存

内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同

静态变量可以通过类名调用，也可以通过对象调用
成员变量只能通过对象名调用

1.5.3.2 main方法是静态的

public static void main(String[] args) {}
public 被jvm调用，访问权限足够大。
static 被jvm调用，不用创建对象，直接类名访问
void被jvm调用，不需要给jvm返回值
main 一个通用的名称，虽然不是关键字，但是被jvm识别

1.6 构造方法

构造方法作用概述

给对象的数据进行初始化

构造方法格式

方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值

构造方法注意事项

如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的

1.7 代码块

在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块。

局部代码块

在方法中出现；限定变量生命周期，及早释放，提高内存利用率

构造代码块

在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

静态代码块

在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；
用于给类进行初始化，在加载的时候就执行，并且值执行一次。