修饰符

2023-11-17 08:41:46

package

1、包的概念
- 包就是文件夹，用来管理类文件的
2、包的定义格式
- package 包名; (多级包用.分开)
- 例如：package com.heima.demo;
3、带包编译&带包运行
- 带包编译：javac –d . 类名.java
  - 例如：javac -d . com.heima.demo.HelloWorld.java
- 带包运行：java 包名+类名
  - 例如：java com.heima.demo.HelloWorld

import

导包的意义

使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了

为了简化带包的操作，Java就提供了导包的功能
导包的格式

格式：import 包名;

范例：import java.util.Scanner;
示例代码（没有使用导包，创建的Scanner对象）

package com.heima;

public class Demo {
    public static void main(String[] args) {
        //没有导包，创建Scanner象
        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) {
        // 导包后创建的Scanner对象
        Scanner sc = new Scanner(System.in);
    }
}

修饰符

修饰符分为权限修饰符和状态修饰符

权限修饰符

同一个java文件中（一个文件可以有多个类）所有权限的成员都可以被访问。不同包的无关的类只能访问public权限的成员。

不加修饰符表示包级可见。
protected用于修饰成员，表示在继承体系中成员对于子类可见，但是这个修饰符对于类没有意义。

final

在Java中，final称为终结器，可以修饰类、方法和属性。

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

fianl修饰类：该类不能被继承（不能有子类，但是可以有父类。如果只是进行应用开发的话，那么大部分情况下不需要使用final来定义类。只有在进行系统架构的代码开发时，才有可能会用到这样的代码。常见的String类就是final定义的，所以String类不允许被继承。）
final修饰方法：该方法不能被重写（如果父类的某些方法具备一些重要的特征，且不希望子类破坏这些重要特征，就可以将方法声明为final。private 方法隐式地被指定为 final，如果在子类中定义的方法和基类中的一个 private 方法名称相同，此时子类的方法不是重写，而是在子类中定义了一个新的方法。）
final修饰基本类型：使数值不变（常量必须在定义时设置好内容，并且不能修改。Java命名规范要求常量全部采用大写，以便于和变量区别）

final修饰引用类型：是引用不变（也就是不能引用其他对象，但是被引用的对象本身是可以修改的）

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

static

Java的内存区域

java中有三块内存空间，名称和作用如下：

栈内存空间：保存引用的堆内存空间的地址；
堆内存空间：保存每个对象的具体属性内容；
全局方法区：保存所有的方法定义。方法区中有一块静态域，保存static类型的变量和方法。

类由属性和方法构成，每一个对象分别拥有各自的属性内容，如果类中的某个属性希望定义为公共属性，可以在声明属性前加上static关键字。

static修饰域

在类加载的时候一起加载入方法区中的静态域中
先于对象存在
被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
访问方式：对象名.属性名类名.属性名（推荐）

public class Book {
    private String title;
    private double price;
    public static String pub = "清华大学出版社";//所有对象的共同属性，为了方便操作，暂不封装
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }
    public String getInfo(){
        return "书名："+this.title+". 价格："+this.price+".出版社："+this.pub;
    }
}
//测试类
public class Application {
    public static void main(String[] args) {
        Book ba = new Book("learn java",34.4);
        Book bb = new Book("learn python",43.4);
        System.out.println(ba.getInfo());
        System.out.println(bb.getInfo());
        System.out.println("=============");
        ba.pub = "TongJi publication";
        System.out.println(ba.getInfo());
        System.out.println(bb.getInfo());

    }
}
/*运行结果如下
书名：learn java. 价格：34.4.出版社：清华大学出版社
书名：learn python. 价格：43.4.出版社：清华大学出版社
=============
书名：learn java. 价格：34.4.出版社：TongJi publication
书名：learn python. 价格：43.4.出版社：TongJi publication
/

因为属性前有static，这个属性将成为公共属性，也就是说任何一个对象修改了此属性的内容都将影响到其他对象。既然static是一个公共属性的概念，那么由一个普通的对象去修改此属性就不太合适，最好由所有对象的公共代表来修改此属性，这个公共代表就是类。所以static属性建议类名称来直接调用。

Book.pub = "Tongji publication";

static属性和非static属性的最大区别就是：所有的非static属性都必须产生实例化对象才可以访问，但是static属性不受实例化对象的控制，也就是说，在没有实例化对象产生的情况下，依然可以使用static属性。不过static属性（类变量）不常出现，一般只有在描述共享属性概念或者是不受实例化对象限制的属性时才会使用，不多数情况下依然使用非static属性（实例变量）。
static 关键字只能用于修饰成员变量，不能用于修饰局部变量。

static修饰方法

静态方法在类加载的时候就存在了，它不依赖于任何实例。所以静态方法必须有实现，也就是说它不能是抽象方法(abstract)。

package testStatic;

public class Book {
    private String title;
    private double price;
    private static String pub = "清华大学出版社";
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }
    public static void setPub(String p){//定义static方法可以直接由类名称调用
    	this.pub = p;
        //this.title = "learn java";报错，static方法不能访问非static方法
    }
    public String getInfo(){
        return "书名："+this.title+". 价格："+this.price+".出版社："+this.pub;
    }
}

public class Application {
    public static void main(String[] args) {
        Book.setPub("TongJi publication");//在没有对象产生的时候调用
        Book ba = new Book("learn java",34.4);
        Book bb = new Book("learn python",43.4);
        System.out.println(ba.getInfo());
        System.out.println(bb.getInfo());
    }
}
/*console:
书名：learn java. 价格：34.4.出版社：TongJi publication
书名：learn python. 价格：43.4.出版社：TongJi publication
/

以上例子可以看出static定义的属性和方法都不受实例化对象的控制，也就是说都属于独立类的功能，但是这样就产生了两种属性和两种方法：

static方法只能调用static属性和方法，不能直接访问非static属性或方法（因为static修饰的方法和属性先于对象存在）
非static方法可以访问static的属性和方法，不受任何限制；

静态块

静态代码块在类初始化时运行一次。

public class A {
    static {
        System.out.println("123");
    }
    public static void main(String[] args) {
        A a1 = new A();//console：123
        A a2 = new A();
    }
}

静态内部类

非静态内部类依赖于外部类的实例，而静态内部类不需要。
静态内部类不能访问外部类的非静态的变量和方法。

public class OuterClass {
    class InnerClass {
    }

    static class StaticInnerClass {
    }

    public static void main(String[] args) {
        // InnerClass innerClass = new InnerClass(); // ‘OuterClass.this‘ cannot be referenced from a static context
        OuterClass outerClass = new OuterClass();
        InnerClass innerClass = outerClass.new InnerClass();
        StaticInnerClass staticInnerClass = new StaticInnerClass();
    }
}

静态导包

在使用静态变量和方法时不用再指明 ClassName，从而简化代码，但可读性大大降低

import static com.xxx.ClassName.*

初始化顺序

存在继承的情况下，初始化顺序为:

父类(静态变量、静态语句块)
子类(静态变量、静态语句块)
父类(实例变量、普通语句块)
父类(构造函数)
子类(实例变量、普通语句块)
子类(构造函数)

静态变量和静态代码块的初始化顺序取决于在代码中的顺序。

主方法的进一步理解

package testStatic;

/*public class testDemo {
    public static void main(String[] args) {
        fun();
    }
    因为主方法是一个static方法，所以它只能调用static方法，因此定义fun函数的时候必须使用static关键字
    public static void fun(){
        System.out.println("hello");
    }
}*/
public class testDemo{
    public static void main(String[] args) {
        new testDemo().fun();
    }
    //fun函数是一个非static方法，必须通过实例化对象才能调用
    public void fun(){
        System.out.println("hello");
    }
}

类中什么时候定义static方法呢？

答：产生实例化对象是为了在堆中保存属性信息，所以如果一个类中没有产生属性，就没有必要去开辟堆内存保存属性内容了，这时就可以考虑类中的方法全部使用static属性。比如常见的Math类，提供的是科学计算的方法，不需要产生实例化对象，所以大量使用了static修饰符。

修饰符

码农公寓