Java基础补习---Day 08

一、封装

（一）概述

1、封装：隐藏事物的实现细节，对外提供公开的访问方式

2、封装的好处：

（1）隐藏事物的实现细节

（2）提高了代码的复用性

（3）提高了安全性

3、封装的原则：

（1）隐藏事物的属性

（2）隐藏事物的实现细节

（3）对外提供公开的访问方式

（二）private关键字

1、private：关键字，含义：私有的；权限修饰符：规定了被修饰的内容在哪里可以访问，在哪里不能够被访问

2、可以修饰的内容

（1）修饰成员变量

（2）修饰成员方法

（3）修饰构造方法

（4）修饰内部类

3、修饰之后的效果：只能在本来中进行访问，出了这个类就不能被访问

4、private只是封装的一种体现，封装也可以使用其他权限修饰符

public class Demo01_Private {
    public static void main(String[] args) {
        Person person = new Person();
        person.name = "张三";
        person.age = 23;
        person.show();
        }
    }
    class Person {
        private String name;
        int age;
    public void show() {
        System.out.println(name + "..." + age);
    }
}

（三）get和set

1、当成员变量私有化之后，外界无法直接访问，所以需要提供对外公开的访问方式，来获取成员变量和设置成员变量

2、方式：通过方法来实现

（1）外界可以访问方法

（2）方法和成员变量同属于类的成员，方法能访问自己类型中私有的成员变量

（3）外界访问方法，方法访问私有成员变量，从而达成间接访问

3、一般使用set方法设置值，使用get方法获取值

4、一般情况下，书写类，属性都要用private进行修饰，并且对每一个成员变量提供一套对应的get、set方法

public class Demo01_Private {
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("迪丽热巴");
        System.out.println(p.getName());
        }
    }
    class Person {
        private String name;
        private int age;
        private String sex;
        public String getName() {
            return name;
        }
        public void setName(String str) {
            name = str;
        }
}

（四）this关键字

1、作用：表示当前类型当前对象的引用

2、哪个对象来调用this关键字所在的方法，this就指代当前的这个对象

3、在set方法中，参数列表是传进来的新值，所以赋值符号右边是参数列表的值，左侧this.name指代的是当前类型中的成员变量

public class Demo01_Private {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.setName("迪丽热巴");
        System.out.println(p1.getName());
        Person p2 = new Person();
        p2.setName("古力娜扎");
        System.out.println(p2.getName());
        }
    }
class Person {
    private String name;
    private int age;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

（五）构造方法

1、作用：用于给成员变量赋值，在创建对象的过程中，会自动调用构造方法，等对象创建完毕的时候，

对象中的成员变量就已经通过构造方法赋值成功了

2、构造方法定义格式

public 类名(形式参数) {
    方法体;
}

3、说明

（1）构造方法没有返回值类型，连void都没有

（2）构造方法的方法名必须和类名保持一致

4、其它

（1）构造方法不能手动调用，在创建对象的过程中会有JVM自动调用

（2）因为一个对象只能创建一次，所以构造方法针对同一个对象只能调用一次

（3）构造方法可以重载

（4）如果没有书写任何构造方法的时候，官方会默认提供一个空参构造，如果自己写了构造方法，就不会提供任何构造方法

public class Demo02_Con {
    public static void main(String[] args) {
        Student s = new Student("张无忌", 30, "男");
        s.setName("谢逊");
        Student s2 = new Student("周芷若", "女");
        System.out.println(s.getName() + "..." + s.getAge() + "..." +
        s.getSex());
        System.out.println(s2.getName() + "..." + s2.getSex());
    }
}
/**
* 如果没有书写任何构造方法的时候，官方会默认提供一个空参构造
* 如果自己写了构造方法，就不会提供任何构造方法
*/
class Student {
    private String name;
    private int age;
    private String sex;
    public Student() {
    }
    public Student(String name, String sex) {
        this.name= name;
        this.sex = sex;
    }
    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public String getSex() {
        return sex;
    }
}

（六）set和构造

1、构造方法和set方法都是用于给成员变量赋值的

2、区别：

（1）构造方法在对象加载的时候由JVM自动调用，针对同一个对象只能调用一次；set方法在创建对象之后由对象名手动调用，set方法可以调用多次针对同一个对象

（2）构造方法可以对多个属性同时进行赋值，在调用的时候注意传参的类型、顺序、个数；set方法只能对一个属性进行操作

（3）构造方法相对比较死板，创建对象之后就不能进行修改；set方法相对灵活，可以多次修改

（七）创建对象赋值

1、创建对象的时候，成员变量经历了三个初始化

（1）默认初始化

（2）构造方法初始化

（3）显式初始化

2、执行顺序：构造方法初始化 < 显式初始化 < 默认初始化

public class Demo03_NewInstance {
    public static void main(String[] args) {
        /**
        * 默认初始化、构造方法初始化、显式初始化
        * 默认初始化----默认初始化
        * 默认初始化、构造方法初始化----构造方法初始化
        * 默认初始化、显式初始化----显式初始化
        * 默认初始化、构造方法初始化、显式初始化----构造方法初始化
        * 构造方法初始化 < 显式初始化 < 默认初始化
        */
        Fruit f = new Fruit("苹果");
        System.out.println(f.getName());
    }
}
class Fruit {
    private String name = "香蕉";
    public Fruit(String name) {
        this.name = name;
    }
    public Fruit() {}
    public String getName() {
        return name;
    }
}

二、制作标准类

JavaBean是Java语言编写类的一种标准规范。该类要求是具体的和公开的，并且具有无参有参构造、提供对应的set、get方法，toString()方法

（一）格式

public class 类名 {
    //成员变量
    //构造方法
    //无参构造
    //有参构造
    //成员方法
    //set方法
    //get方法
}

（二）示例代码

public class Demo04_Test {
    public static void main(String[] args) {
        Teacher t = new Teacher("高启盛", 30, "男", "吃鱼");
        System.out.println(t.getName() + "..." + t.getAge() + "..."
        + t.getSex() + "..." + t.getHobby());
    }
}

public class Teacher {
    //属性：姓名、年龄、性别、爱好
    private String name;
    private int age;
    private String sex;
    private String hobby;
    //构造方法
    public Teacher() {
    }
    public Teacher(String name, int age, String sex, String hobby) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.hobby = hobby;
    }
    //set、get方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getHobby() {
        return hobby;
    }
    public void setHobby(String hobby) {
        this.hobby = hobby;
    }
}

三、Math

1、两个常量：

（1）E：自然对数的底数

（2）PI：圆周率

2、常用方法

（1）abs(int a)：求绝对值

（2）cbrt(double a)：开立方

（3）sqrt(double a)：开平方

（4）ceil(double a)：向上取整

（5）floor(double a)：向下取整

（6）max(int a, int b)：求最大值

（7）min(int a, int b)：求最小值

（8）pow(double a, double b)：求a的b次方

public class Demo05_Math {
    public static void main(String[] args) {
        //(1) abs(int a): 求绝对值
        int num = Math.abs(-10);
        System.out.println(num);
        //(2) cbrt(double a):开立方
        System.out.println((int) Math.cbrt(8));
        //(3) sqrt(double a):开平方
        System.out.println(Math.sqrt(9));
        //(4) ceil(double a): 向上取整
        System.out.println(Math.ceil(9.2));
        //(5) floor(double a):向下取整
        System.out.println(Math.floor(9.9));
        //(6) max(int a, int b): 求最大值
        System.out.println(Math.max(3, 6));
        //(7) min(int a, int b):求最小值
        System.out.println(Math.min(5, 8));
        //(8) pow(double a, double b):求a的b次方
        System.out.println(Math.pow(5, 2));
    }
}

四、Arrays

1、概述：关于数组操作的类

2、常用方法：

（1）binarySearch(int[] a, int key)：传入一个数组，传入一个指定值，查看当前数组是否包含指定

值，如果包含返回该值的索引，不过不包含则返回-1；并且在使用该方法之前必须进行排序

（2）sort(int[] a)：对数组进行升序排序

（3）toString(int[] a)：返回指定数组内容的字符串表示形式

（4）copyOf(int[] original, int newLength)：拷贝数组，如果新数组的长度小于原数组就是截取，如果新数组的长度大于原数组超出部分使用默认值进行填充

（5）equals(int[] a, int[] a2)：如果两个指定的数组彼此相等，则返回true

（6）fill(int[] a, int val)：用指定元素替换指定数组中的所有元素

import java.util.Arrays;
public class Demo06_Arrays {
    public static void main(String[] args) {
        int[] arr1 = {34, 76, 89, 41, 66, 24, 94, 67};
        int[] arr2 = {56, 87, 11, 77, 34, 93, 22, 61, 74, 37};
        //(2) sort(int[] a):对数组进行升序排序
        Arrays.sort(arr1);
        //(1) binarySearch(int[] a, int key):传入一个数组，传入一个指定值,
        // 查看当前数组是否包含指定值,如果包含返回该值的索引，不 过不包含则返回1;并且在使用该
        方法之前必须进行排序
        System.out.println(Arrays.binarySearch(arr1, 66));
        //(3) toString(int[] a):返回指定数组内容的字符串表示形式
        System.out.println(Arrays.toString(arr1));
        //(4) copyOf(int] original, int newLength):拷贝数组，如果新数组的长度小于原数组就是截取,
        // 如果新数组的长度大于原数组超出部 分使用默认值进行填充
        int[] newArr = Arrays.copyOf(arr1, 20);
        System.out.println(Arrays.toString(newArr));
        //(5) equals(int[] a, int[] a2):如果两个指定的数组彼此相等，则返回true
        System.out.println(Arrays.equals(arr1, arr2));
        //(6) fill(int[] a, int val):用指定元素替换指定数组中的所有元素
        Arrays.fill(arr2, 6);
        System.out.println(Arrays.toString(arr2));
    }
}

五、静态

（一）概述

1、概述：如果所有对象，都具有一个共同的属性值，那么在这个属性值上加一个static，此时该变量就

会从存储在堆内存中变成了存储在方法区的静态区，从每一个对象拥有一份变成了所有对象共享一份

public class Demo07_Phone {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.setName("华为");
        p1.setColor("黑色");
        Phone p2 = new Phone();
        p2.setName("苹果");
        p2.setColor("红色");
        System.out.println(p1.getName() + "..." + p1.getColor());
        System.out.println(p2.getName() + "..." + p2.getColor());
    }
}
class Phone {
    private String name;
    private static String color;
    public Phone() {
    }
    public Phone(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}

（二）静态变量的特点

1、static：关键字，含义：静态；被static修饰的成员就是静态的

2、静态变量不会随着对象的变化而变化

3、加载时机：优先于对象存在，随着类的加载而加载

4、静态变量被所有对象共享

5、访问方式

（1）可以通过类名访问：【类名.变量名】

（2）可以通过对象名访问：【对象名.变量名】不建议

6、静态变量在不创建对象的情况下也可以访问

（三）静态方法的特点

1、概述：在方法的声明上加上static进行修饰

2、非静态可以访问静态

3、静态只能访问静态，静态不能访问非静态

（1）静态不能访问非静态变量

（2）静态方法不能访问非静态成员变量

（3）静态方法中不能使用this关键字

4、静态方法访问

（1）对象名.方法名();【不建议】

（2）类名.方法名();【推荐使用】

public class Demo08_StaticMethod {
    public static void main(String[] args) {
        new MyClass().show("", "");
        MyClass.show("", "");
    }
}
class MyClass {
    String name = "高启强";
    static String sex = "男";
    public void test(String name, String sex) {
        //非静态方法中可以使用this关键字
        this.name = name;
        this.sex = sex;
        //非静态方法可以访问非静态以及静态成员变量
        System.out.println(name + sex);
        //非静态方法可以访问静态方法
        show("", "");
        System.out.println("非静态方法执行了");
    }
    public static void show(String name, String sex) {
        // 静态方法中不能使用this关键字
        //this.name = name;
        //this.sex = sex;
        // 静态方法不能访问非静态成员变量
        // System.out.println(name + sex);
        // 静态方法不能访问非静态方法
        // test();
        System.out.println("静态方法执行了");
    }
}

（四）静态变量和非静态变量的区别

1、概念上，所属不同

（1）非静态变量：属于对象

（2）静态变量：属于类

2、内存空间不同，存储位置不同

（1）非静态变量随着对象的创建而创建在堆内存中

（2）静态变量随着类的创建而创建在方法区的静态区中

3、生命周期不同

（1）非静态变量随着对象的创建而创建，随着对象的消亡而消亡

（2）静态变量随着类的创建而创建，随着类的消亡而消亡

4、访问方式不同

（1）非静态方法：只能采用对象名去调用

（2）静态方法：可以使用对象名调用，也可以使用类名调用【推荐类名】