七.修饰符

七.修饰符

1.private

概念：私有的，一种访问权限修饰符，用来修饰类的成员。
特点：被修饰的成员只能在本类中访问。(只能在本类中使用)
用法：private 数据类型 变量名;
     private 返回值类型 方法名(参数列表){}

package Winter.modifier.private01;
/***
 * 给Student类中的成员变量用private修饰，然后在测试类中正确使用该类的成员变量
 */
public class Student01 {
    //成员变量
    String name;
    private int age;
    //提供公共的访问方式
    public void setAge(int a){
        //对age的值进行限定
        if (a > 150 || a <= 0){
            //非法输入
            age = 1;
        }else {
            //合法输入
            age = a;
        }
    }
    public int getAge(){
        return age;
    }
    //成员方法
    public void study(){
        System.out.println(name + "正在努力学习......");
    }
}
/**
 * private一般用来修饰成员变量；
 * public一般用来修饰成员方法。
 * 测试类*/
public class StudentTest01{
    public static void main(String[] args) {
        Student01 s1 = new Student01();
        s1.name = "melody";
        s1.setAge(20);
        System.out.println(s1.getAge());
        s1.study();
    }
}

2.this

表示本类对象的引用，本质是一个对象。
特点：每一个普通的方法都有一个this，谁调用该方法，this就指向谁。
用法：this.属性名;
     this.方法名;

package Winter.modifier.this01;
/***
 *案例：使用this完善set方法
 * 需求：Student类中的set方法的参数名应按规范命名
 * 将set方法参数名按规范改写后，会与成员变量重名，使用this关键词进行区分
 */
public class Student01 {
    //成员变量
    private int age = 20;
    //设置年龄
    public void setAge(int age) {
        this.age = age;
    }
    //获取年龄
    public int getAge() {
        return age;
    }
    public void show() {
        //局部变量
        int age = 21;
        System.out.println(age);
        System.out.println(this.age);//调用成员变量的age；
    }
}
//测试类
public class StudentTest01 {
    public static void main(String[] args) {
        //1.调用show方法
        Student01 s1 = new Student01();
        s1.show();
    }
}

3.abstract

抽象类：包含抽象方法的类。用abstract修饰。
         抽象类的成员比普通类多一种抽象方法，其他和普通类一样。
实例化：通过创建其子类对象完成初始化操作。
  抽象类的子类：
    如果是普通类，必须重写所有的抽象方法。
    如果是抽象类，则不用重写抽象方法。
  抽象方法：只有方法声明，没有方法体的方法，用abstract修饰。
  由来：当需要定义一个方法时，不明确方法的具体实现，可以将方法定义为abstract，具体实现延迟到子类。

package Winter.modifier.abstract01;
//父类
public abstract class Animal02 {
    //有参构造方法
    public Animal02(String name) {
        this.name = name;
    }
    //无参构造方法
    public Animal02() {
    }
    //成员变量
    String name = "melody";
    //成员常量
    final int AGE = 30;//大写命名
    //吃
    public abstract void eat();
    //睡
    public abstract void sleep();
    public void call(String name) {
        System.out.println(this.name+"会叫");
    }
//子类
public abstract class Dog02 extends Animal02{
}
//测试类
public class Test02 {
    public static void main(String[] args) {
        //初始化抽象类(抽象类不能直接new)
        Animal02 a1 = new Cat02();
        //抽象类的成员特点
        a1.name = "cyl";
        System.out.println(a1.name);
        //a1.AGE = 33;//常量的值不能发生改变
        a1.call("sss");
    }
}

4.final

作用：修饰的类不能被继承，但是它可以继承其他类。
      修饰的方法不能被重写，不能与abstract共存。
      修饰的变量为最终变量(即常量)，只能赋值一次。

package Winter.modifier.final01;
//人类
public class Person01 {
}
//员工类
public class Employee01 {
    String name;
    int age;
    public void show() {
        System.out.println("绝密文件");
    }
}
//码农类
public class Coder01 extends Employee01{
    @Override
    public void show() {
        System.out.println("教务文件");
    }
}
//测试类
/**
 * final关键字:
 * 在Java中可以修饰类，成员变量，成员方法。
 * 修饰的类不能被继承，但是它可以继承其他的类。
 * 修饰的方法不能被重写。
 * 修饰的变量:是一个常量，其值只能设置一次。
 * 修饰的变量：引用类型的变量，是地址值不能改变，但是属性值可以发生变化。
 * */
public class Test01 {
    public static void main(String[] args) {
        Employee01 e1 = new Coder01();
        e1.show();
        //final修饰的变量：基本类型的变量，是值不能改变。
        final int CC = 20;
        //CC = 22;//代码报错
        System.out.println(CC);
        //final修饰的变量：引用类型的变量，是地址值不能改变，但是属性值可以发生变化。
        final Employee01 e2 = new Employee01();
        //e2 = new Employee01();代码报错原因：只要new就会开辟新空间
        System.out.println("name属性值："+e2.name);
        System.out.println("age属性值："+e2.age);
    }
}

5.static

1.概念：静态的
2.作用：用于修饰类的成员(修饰后的成员方法：类方法；修饰后的成员变量：类变量)
3.调用方式：类名.成员变量名; 类名.成员方法名(参数);
  注意事项：随意修改静态变量的值是有风险的，为了降低风险，可以同时用final关键字修饰，即
           公有静态常量(注意命名变化)
  static修饰成员变量：
    1.特点：被本类所有对象共享。
  static修饰成员方法：
    1.静态方法：
      静态方法中没有对象this，所以不能访问非静态成员。
    2.静态方法的使用场景
      只需要访问静态成员。
      不需要访问对象状态，所需参数都由参数列表显示提供。
    3.调用的方法：
      类名.

package Winter.modifier.static01;
/***
 * 反转数组元素方法
 */
public class ReverseArray02 {
    int a1 = 10;
    static int a2 = 11;
    //静态方法中没有对象this，所以不能访问非静态成员。
    public static void show() {
        System.out.println();
    }
    public static void reverse(int[] arr) {
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
    }
}
//测试类，反转数组元素
public class Test02 {
    public static void main(String[] args) {
        //交换变量
        int a = 20;
        int b = 30;
        int temp = a;
        a = b;
        b = temp;
        //System.out.println(a);
        //System.out.println(b);
        int[]a1 = {12,13,12,14,17,39,33,444};
        for (int i = 0; i < a1.length; i++) {
            System.out.print(a1[i]+" ");
        }
        System.out.println();
        //调用方法
        ReverseArray02.reverse(a1);
        for (int i = 0; i < a1.length; i++) {
            System.out.print(a1[i]+" ");
        }
    }
}