【详细+超基础】Java-学习笔记 09

修饰符

1.1 package与 import

• 包的概念 包就是文件夹，用来管理类文件的
  
• 包的定义格式 package 包名; (多级包用.分开) 例如：package com.jumper.demo;
  
• 带包编译&带包运行 带包编译：javac –d . 类名.java 例如：javac -d . com.jumper.demo.HelloWorld.java 带包运行：java 包名+类名 例如：java com.jumper.demo.HelloWorld
  
• 导包的意义 使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了 为了简化带包的操作，Java就提供了导包的功能
  
• 导包的格式 格式：import 包名; 范例：import java.util.Scanner;
  
• 示例代码（没有使用导包，创建的Scanner对象）
  

package com.heima;
public class Demo {
  public static void main(String[] args) {
  // 1. 没有导包，创建Scnaner对象
java.util.Scanner sc = new java.util.Scanner(System.in);
  }
}

• 示例代码（使用导包后，创建的Scanner对象）

package com.heima;
import java.util.Scanner;
public class Demo {
  public static void main(String[] args) {
  // 1. 没有导包，创建Scnaner对象
    Scanner sc = new Scanner(System.in);
  }
}

1.2 访问修饰符

在前面定义类时使用了public，定义属性时使用了private，定义方法时使用了public。它们都是java的访问修饰符。java一共定义了四种访问权限控制符：private、默认访问权限、protected、public,通过权限控制符合包能够控制访问权限。

• private
  private可以用来修饰成员变量、成员方法、构造方法以及内部类（内部类是定义在另 个类里面的类，跟成员变量一样属于另一个类的成员)。private 修饰的成员只能被它所属的 类内的其他方法访问，不能被该类以外的其他类访问。
  
• 默认访问权限 默认访问权限也称为包访问权限，不写访问控制符的就是默认访问权限。默认访问权限可以用来修饰成员变量、成员方法、构造方法、类和接口。默认访问权限定义的内容可以被同一个包中的类所访问，包括它本身，但不能被别的包中的类访问。
  
• protected protected可以用来修饰成员变量、成员方法、构造方法以及内部类。protected 修饰的成员可以被同一个包内的其他类访问，不同包如果是它的子类也可以访问，其他包中不是它的子类的类不能访问。
  
• public public可以用来修饰成员变量、成员方法、构造方法以及类和接口。pulie修饰的成员可以被任何类访问，无论是否在同一一个包内。

访问权限表

类变量、实例变量与局部变量

定义在类体内且在方法外的变量称为成员变量，定义在方法内的变量称为局部变量。

成员变量：

类的成员变量有两种:一种是类变量，一种是实例变量，定义成员变量时，若变量前有关键字static, 则称为类变量， 若没有static 关键字，则称为实例变量。类变量存储在类的公用区，属于类所有，所有该类的对象共享这一个类变量;而实例变量属于对象所有，每个对象拥有自己独立的实例变量，保存在对象的内存中。

局部变量：

定义在方法中的变量称为局部变量。局部变量也有两种:一种是方法的形参，一种是方法体内定义的变量。局部变量的生命周期只存在于方法内，方法调用结束，局部变重也就不存在了。

方法体内的局部变量必须赋初值后才能使用，否则编译器认为该变量没有初始化，不能使用。

实例方法与类方法

方法声明时，方法名前不加static的是实例方法，加static的是类方法。 当以类为模板创建多个对象时，则每个对象拥有自己独立的实例方法，但是所有对象共用类的类方法。

(1)  实例方法调用。

对象名.方法();

(2) 类方法调用。 调用类方法有两种格式:  “对象名.方法0”    或者   “类名方法0”，建议使用  “类名方法()”。

**案例：**编写一个员工类，假设所有员工的基本工资都一样，但津贴不一样，员工类 具有返回总薪水的方法和普调工资的方法，具体代码如下:

public class Employee {
    static double wage;  // 基本工资，static变量，所有对象都一样
    double allowance;    // 津贴，实例变量，每个对象的津贴可能都不一样
    public double getSalary() { //实例方法。可以使用实例变量和类变量
        return wage+allowance;
    }
    public static void addWage(int a) {
        wage=wage+a;
        // allowance=allowance+a; 错误：因为类方法只能使用类变量
    }
    public static void main(String[] args) {
        Employee e1=new Employee();
        Employee.wage=1000;
        e1.allowance=200;
        Employee.addWage(500);
        System.out.println(e1.wage);
        System.out.println(e1.getSalary());
    }
}

**总结：**类方法属于类所有，第一次加载类时就存在于类的内存了，不用创建对象就可以使用，所以类方法只能使用类变量，因为它们都是在类加载时就存在了。但实例变量不同，实例变量必须在创建了对象后才存在于对象的内存里，所以类方法不能使用实例变量。实例方法是在对象创建后才存在，有了实例方法后，类变量和实例变量肯定都存在了，所以实例方法可以使用类变量和实例变量。

1.1 final关键字

• fianl关键字的作用

      final代表最终的意思，可以修饰成员方法，成员变量，类

• final修饰类、方法、变量的效果

      fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

      final修饰方法：该方法不能被重写

      final修饰变量：表明该变量是一个常量，不能再次赋值

• fianl修饰基本数据类型变量

      final 修饰指的是基本类型的数据值不能发生改变

• final修饰引用数据类型变量

      final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

      举例：

public static void main(String[] args){
  final Student s = new Student(23);
  s = new Student(24); // 错误
  s.setAge(24); // 正确
}

1.2 static关键字

• static的概念

     static关键字是静态的意思，可以修饰【成员方法】，【成员变量】

• static修饰的特点

     被类的所有对象共享，这也是我们判断是否使用静态关键字的条件

     可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】

示例代码：

class Student {
  public String name; //姓名
  public int age; //年龄
  public static String university; //学校 共享数据！所以设计为静态！
  public void show() {
    System.out.println(name + "," + age + "," + university);
  }
}
public class StaticDemo {
    public static void main(String[] args) {
        // 为对象的共享数据赋值
        Student.university = "山东建筑大学";
        Student s1 = new Student();
        s1.name = "孙不坚";
        s1.age = 18;
        s1.show();
        Student s2 = new Student();
        s2.name = "孙铭";
        s2.age = 17;
        s2.show();
    }
}

static的访问特点

• 非静态的成员方法

          能访问静态的成员变量

          能访问非静态的成员变量

          能访问静态的成员方法

          能访问非静态的成员方法

• 静态的成员方法

          能访问静态的成员变量

          能访问静态的成员方法

总结成一句话就是： 静态成员方法只能访问静态成员

对象的初始化顺序

• 父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变量(实例变量)、父类非静态代码块、父类构造器(构造方法)、子类非静态变量、子类非静态代码块、子类构造器(构造方法)

• 先父后子，先静态后非静态，先量再块后方法。

代码块的初始顺序

class person{
    private String name;
    static {
        System.out.println("这是静态代码块1");
    }
    {
        System.out.println("这是实例代码块")
    }
     static {
        System.out.println("这是静态代码块2");
    }
    public person (String name) {
        this.name=name;
         System.out.println("这是构造函数");
    }   
}
执行结果如下
    这是静态代码块1
    这是静态代码块2
    这是实例代码块
    这是构造函数

静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。静态代码块是根据我们书写代码的顺序进行执行的,按顺序执行。