1.static

1.1定义

static关键字：表示静态的—静态的资源就是使用static修饰的

其实也是一个修饰符，用来修饰成员（方法和属性）
被static修饰的成员就不再是单个的这个类的某个对象了，在内存中保存在方法区中
1.2记住：
static修饰的成员可以被多个对象共享
static修饰的成员属于类，但是会影响到每一个对象
static修饰的成员又叫做类成员，不是对象成员—是随着类的加载而存在的
比如main方法，就是一个特殊的静态方法，使用static修饰的，是随着类的加载而加载到方法区的
举例子：
比如中国人的国籍都是中文的，不需要自定义自己的国籍，所以可以通过static关键字进行定义为类成员，
属于类，被多个多项共享
国籍，姓名，年龄，职业都是属性，但是国籍被共享因为都是中国
一般static修饰的成员是直接赋值
被static修饰的成员可以并且建议通过类名直接访问
格式：

类名.静态成员变量名
类名.静态成员方法名(参数)
对象名.静态成员变量名 ———不建议，出现警告
对象名.静态成员方法名(参数) ———不建议，出现警告

当多个对象共享static修饰的成员时，只要是该值发生了变化，就会影响到所有的对象 ```java package igeek_01;

/**

@author Lynn
@create 2020-12-02-9:45 */

/**

实体类 / public class Chinese { //普通成员 private String name; private int age; private String work;

//定义一个共享的成员—静态成员—static public static String country=”中国”;

public Chinese() { }

public Chinese(String name, int age, String work) {

 this.name = name;
 this.age = age;
 this.work = work;

}

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 getWork() {

 return work;

}

public void setWork(String work) {

 this.work = work;

}

public static String getCountry() {

 return country;

}

public static void setCountry(String country) {

 Chinese.country = country;

} }

```java
public class StaticDemo {
 public static void main(String[] args) {
     //创建人的对象
     Chinese c=new Chinese("王宝强",37,"演员");
     System.out.println(c.getName()+" "+c.getAge()+" "+c.getWork()+"国家"+c.country);
     Chinese c2=new Chinese("周星驰",60,"演员");
     System.out.println(c2.getName()+" "+c2.getAge()+" "+c2.getWork()+"国家"+c2.country);
     //对country进行重新赋值
     c.country="中华人民共和国";
     System.out.println(c.getName()+" "+c.getAge()+" "+c.getWork()+"国家"+c.country);
     System.out.println(c2.getName()+" "+c2.getAge()+" "+c2.getWork()+"国家"+c2.country);
 }

1.3测试static的使用

静态成员只能直接访问静态成员—可以理解为静态成员只能被调用！

静态资源不能去调用普通成员
原因是因为静态内容优于对象存在的—比对象出现的要早（静态是随着类的加载而加载），因为对象是存在堆中的
```
静态资源的访问通常可以直接使用类名，静态资源进行访问
```
好处是因为static修饰的资源是随着类的加载而直接加载的，所以可以直接访问
类名.静态成员变量
类名.静态成员方法（参数）

1.4 static静态资源的优先级

优先级的加载顺序：
1.静态资源永远是第一个执行的（随着类的加载而加载）
2.main方法中哪一行先写，就先执行哪一行（根据从上往下的顺序）
静态资源是优于main方法先执行的！
1.5静态代码块
定义：
在java中使用static关键字声明的代码块叫静态代码块。

有什么用？

静态块用于初始化类，为类的属性初始化。每个静态代码块只会执行一次。静态代码块随着类加载而加载，有多个静态代码块的，按代码块前后顺序加载。由于JVM在加载类时会执行静态代码块，所以静态代码块先于主方法执行。

什么时候用？

如果有些代码必须在项目启动的时候就执行，那么我们就可以使用静态代码块来实现，这种代码是主动执行的。

2.final

2.1定义

final关键字表示的是最终的；也是一个修饰符，可以修饰类，变量，成员方法
一个java类如果是被final修饰了，那么这个类就不能被继承了
在api中有很多的类这么做，目的是不让程序员随意的拓展自己的功能

2.2重点

1.final修饰的方法不能被重写
2.final修饰的变量不能被重新赋值（对象类型和引用类型）
3.其实在底层要注意，这个变量的值是可以发生改变的，不能改变的是指向！

2.3汇总final的使用

  final是一个修饰符，可以修饰变量，方法，类

final修饰的变量无法被再次赋值
final修饰的方法无法被重写
final修饰的类无法被继承
实际使用中的情况是：连续使用public static final在一个类中定义一个常量，采取直接赋值的方法

注意命名规范，所有的字母均大写，中间可以使用_隔开

public class FinalDemo {
  //定义常量(第一种）
  public static final double PI=3.1415926535;
  //定义常量(第二种）
  public final static double PI1=3.1415926535;
  public static void main(String[] args) {
      //变量
      int a=10;
      a=20;
      final int b=1;
//        b=3;//报错
      //计算圆的面积
      double r=2.5;
      double area=FinalDemo.PI*r*r;//常量的好处是便于代码的维护，
      // 常量的加载时机：常量是在编译期就绑定了
      System.out.println(area);
      //为引用再次赋值,final在这里限制的是p的指向，对象的实际内容不受final的影响
      final Person p=new Person();
      p.setName("王思聪");
      p.setName("林更新");
      System.out.println(p.getName());//林更新
      /**
       * 输出结果是经过重新的赋值，因为当前的p的指向并没有发生改变
       * 而指向的对象的内容发生了改变是可以的！
       * 当前final限制的是p的再次指向
       */
      //不能再次指向
//        p=new Person();
  }
}

3.包（package）

3.1 包

包的作用：

包：是java程序管理资源的一种方式，通常用来保存（封装）类
主要的目的是为了区分编程中的模块
在类中声明包的时候，必须与.class文件所在的文件一致
声明的格式：package（包）.package（子包）.package（子包）···········

如果带包使用其他的类，应该加入全名，即：包名+类名

3.2演示访问权限在包中的使用

1.private —私有的—-只能在本类中访问
2.默认的———————只能在本类和本包中访问
3.protected—保护的（对子类的保护）—只能在同类和同包以及子类中访问，但是在不同包中，子类继承了前面的父类，也可以利用super访问
4.public——公共的—-

Java Advanced 进阶笔记

关键字 &包