java笔记（关于public修饰符，静态成员，static，代码块）

• java修饰符

public修饰类；
protected，default以及private都是修饰成员。
public能够被外包访问（import 包名）

• public：
  具有最大的访问权限，可以访问任何一个在classpath(同一文件夹)下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。

• protected：
  主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西

• default：
  有时候也称为friendly，它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。

• private：
  访问权限仅限于类的内部，是一种封装的体现，例如，大多数成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。

转载自：博客园

https://www.cnblogs.com/jingmengxintang/p/5898900.html

---

• java中的静态成员

• 通常情况下，方法必须通过它的类对象访问。但是如果该方法的使用完全对立于该类的任何对象，可以利用static关键字。通过该关键字可以创建一个方法或者变量，它能够被自己使用，而不用引用特定的示例。在方法或变量前面加上static即可。

• 如果一个方法被声明为static，它就能够在它的类任何对象创建之前被访问，而不必引用任何对象。下面示例中，演示静态方法和静态变量的使用。

public class StaticDemo1
{
     //s为静态变量
      public static String s="我是静态变量";
     //静态方法
      public static void printInfo(){
         System.out.println("我是静态方法");
     }
     public static void main(String[] args){
         //调用StaticDemo1中的printInfo方法时，不需要创建新的
         //StaticDemo1对象，直接访问即可
          StaticDemo1.printInfo();
         //直接调用StaticDemo1中的s变量时，直接访问即可
          System.out.println(StaticDemo1.s);
     }
}

运行结果:

• 在Java中没有一个直接的修饰符来实现常量，而是通过静态成员变量的方式来实现的，如： public static final int X=20;
  static public final intY=30;　 static表示属于类，不必创建对象可以使用，因为常量应该不依赖任何对象，final表示值不能改变。一般用作常量的静态成员变量访问权限设置为public，因为常量应该允许所有的类或对象访问。

• 对于非静态成员变量，系统不会为其分配默认值，必须在构造器完成之前对其初始化。对于静态成员变量，系统也不会为其分配默认值，也要求开发人员必须对其进行初始化。但是静态变量属于类，是不能等到构造器运行在初始化的，因为类加载完成之后其值必须可以使用。在Java中，静态成员变量的的初始化要求在静态语句块结束之前必须完成。即Java中静态成员变量的初始化时机有两个，在声明的同时进行初始化或者在静态语句块中进行初始化。

 1 //功能：初始化静态成员变量介绍
 2  public class StaticDemo2
 3 {
 4     //声明并初始化常量const1
 5      public static final int const1=1111;
 6     //声明常量const2
 7      public static final int const2;
 8 
 9     //下面为静态语句块，是静态成员的一种。在此静态语句中初始化了常量
10     //const2.静态语句块在类加载时执行一次，可以将对类进行初始化的代码写在其中。
11     
12     static {
13         //初始化常量const2
14          const2=2222;
15     }
16     public static void main(String [] args){
17         System.out.println("两个常量的值分别为const1="+const1+",const2="+const2);
18     }
19 }

• 如果将第11到15行注释掉，在次进行编译，就会报“可能尚未初始化变量const2”错误。

• 对于静态成员的访问，可以直接使用"<类名>.<静态成员名>"的语法调用静态成员变量。

1 public class StaticDemo3
2 {
3     int var=13;
4     public static void main(String[] args){
5         System.out.println("成员变量var的值为："+var);
6     }
7 }

编译代码，运行结果：

从上图可以看出，编译报“无法从静态上下文中引用非静态变量 var”错，这是因为main()方法自身便是一个静态方法，而var是非静态成员。因为静态成员不依赖于该类的任何对象，所以当其所在的类加载成功后，就可以被访问了，此时对象并不一定存在，非静态成员自然也不一定存在，静态成员的生命周期比非静态成员的长。即使访问时存在非静态成员，静态方法也不一定知道访问的是哪一个对象的成员，因为静态方法属于类，非静态成员属于对象，所以静态方法将不知道关于其所属类对象的消息。而静态方法访问静态成员时，自然是任何时候都没有问题，静态成员都属于类，只要类存在，静态成员都存在。同样的道理，在静态方法中是不能使用this预定义对象引用的，即使其后边所操作的也是静态成员也不行。因为this代表指向自己对象的引用，而静态方法是属于类的，不属于对象，其成功加载后，对象还不一定存在，也不知道this指的是哪一个对象。

1 public class StaticDemo4
2 {
3     static int x=100;
4     public static void main(String[] args){
5         int y=this.x;
6     }
7 }

编译后，运行结果：

转自： https://www.cnblogs.com/wannianma/archive/2011/04/03/wannianma.html

---

• static特点

1. 被所有的对象所共享
2. 可以使用类名调用
3. 静态的加载优先于对象
4. 随着类的加载而加载

• static的注意事项：

• 静态方法：

1. 可以调用静态的成员变里
2. 可以调用静态的成员方法
3. 不可以调用非静态成员变里
4. 不可以调用非静态成员方法
5. 静态方法只能调用静态的成员

• 非静态方法：

1. 可以调用静态的成员变量
2. 可以调用静态的成员方法
3. 可以调用非静态的成员变里
4. 可以调用非静态的成员方法

静态的方法中没有this这个对象

• static的优点

• 对对象的共享数据提供单独空间的存储，节省空间， 没有必要每一个对象都存储一份
• 可以直接被类名调用，不用在堆内存创建对象

• static的弊端

• 访问出现局限性。(静态虽好，但只能访问静态)

---

Math函数（工具类）
Math.ceil()
向上取整
Math.floor()
向上取整
Math.round()
四舍五入

---

• 工具类的创建

1. 将构造方法设置为private
2. 工具类中的方法用static修饰
3. 原理：static随着类的加载而加载，优先于对象的创建，故可以在不创建对象的情况下直接用类引出方法。

---

• 代码块{}

局部代码块：

• 存在于方法中，控制变量生命周期（作用域）

构造代码块：

• 抽取构造方法中的共性，每次创建对象都会执行
• 在构造方法的上方下方均可
• 优先执行构造代码块中的内容，再执行运行构造方法中的内容

静态代码块：

• 形式：static{}
• 随着类的加载而加载，且只加载一次，加载类时需要做的一些初始化，例如驱动

---

• 代码块执行顺序

Coder静态代码块执行—Coder构造代码块执行—Coder无参空构造执行

BlockTest静态代码块执行—BlockTest的主函数执行—Coder静态代码块执行—Coder构造代码块执行—Coder无参空构造执行—Coder构造代码快执行—Coder无参空构造执行

public class BlockTest {
	static {
		System.out.println("BlockTest静态代码块执行");
	}
	{	System.out.println("BlockTest构造代码块执行");
	}
	public BlockTest() {
		System.out.println("BlockTest无参构造执行");
	}
	
	public static void main(String[] args) {
		Coder c = new Coder();
		Coder c1 = new Coder();
	}
}
class Coder {
	static{
		System.out.println("Coder静态代码块执行");
	}
	{
		System.out.println("Coder构造代码块执行");
	}
	public Coder() {
		System.out.println("Coder无参构造执行");
	}
}