20180112final和static

final关键字

fianl关键字可以修饰类、成员变量、和方法中的局部变量。

（java中的局部变量？定义在方法中的变量都是局部变量，使用前必须初始化）

1.fianl类

Final类不能被继承，即可以看成为终结类。

如：

final class A{

…

}

2.final方法

若用final修饰父类中的一个方法，那么不允许子类隐藏可以继承的fianl方法。 //有点不懂？

3.常量

用fianl定义的变量可以看为常量，且在运行期间不会发生变化，在声明时候不指定初始值，在

使用之前，必须对其赋值，而且不能再重新赋值。

Circle.java
public class Circle{
	final double PI=3.1415926;
    //声明名字是PI的final常量，其值为3.1415926

    double radius;
    public void setRadius(fianl double r){
       radius=r;
    }
    public fianl double getArea(){
    	return PI*radius*radius;
    	//定义计算面积是double getArea()方法，该方法必须是final
    }
}
Application5_7.java
public class Application5_7{
	public static void main(String[] args) {
		Circle c=new Circle();
		c.setRadius(38.26);
		System.out.println("面积%5.3f\n",c.getArea());
	}
}

　　

Static关键字主要有两种作用：

1.为特定对象或数据分配特定空间。

2.在不创建对象的情况下就可以通过类来直接调用类的方法或属性。

static主要有4种使用情况：成员变量、成员方法、代码块和内部类；

1）static成员变量

通过static来达到全局变量的效果；

用static修饰的变量叫静态变量，也叫类变量，没static修饰的叫实例变量；

static变量被分配到同一块内存中，用法：类名.静态变量 或对象.静态变量；

实例变量只有在创建对象时候才能够被分配内存，并且存在多个复制，只能用对象.静态变量；

2）static方法

它只能访问属于类的static方法，它的内存块是同一块（即会随着改变而改变，且以最后一次修改为主），

而普通成员方法或实例方法，它们的对象的变量的内存块有多块，某个对象的改变不会影响其它的改变，

因为它们在不同的内存块，彼此相互独立。

public class TestStatic1{
	public static void main(String[] args) {
		/*Dog d=new Dog();
		d.setName("j dog");
		d.setAge(100);

		Dog d1=new Dog();
		d.setName("c dog");
		d.setAge(10);*/

		Dog d=new Dog();
		d.Strs[0]="a";
		d.Strs[2]=“b”;
		d.Strs[0]="hello";
		d.Strs[2]="go";

		//d=d1;
       System.out.println(d1.strs[0]);//hello
		System.out.println(d.strs[2]);//go
		}
	public static void main(String[] args){
		testDog();
	}
}

　　

总结：

从内存来看静态区和对象区；

加载类对象的时候，静态去自动加载；

非静态语句块随着对象的创建而创建（默认调用）

静态语句块，类加载的时候被调用执行，仅有一次（默认调用）

//两个静态对象共享变量，对象区域的两个对象共享一个静态方法，以最后一个修改的值为主，前一个被覆盖了

//先申明后创建对象

总结：

在创建对象的同时

1.静态块

2.非静态块

3.构造器

//调用非静态方法，通过对象调用（对象必须不为空）

2.实例变量与类变量的区别

1）不同的实例变量互不相同（在内存中的位置不同，且互不影响）

2）所有的对象共享类变量：若类中有类变量，当new出多个对象时，这些对象的类变量占有

相同的一处内存，改变其中一个对象的类变量会影响其它对象的这个类变量，即共享该类变量。

（占有内存中同一位置，多个对象共享它，任意一个对象改变它都会影响）

3）通过类名直接访问类变量（要写代码来测试或感受一下）

一个类创建一个对象，对应的实例变量就会分配一块内存，多个实例变量会分配不同内存，

如果是类变量，不在重新分配内存，所有对象共享类变量，即所有的对象的类变量是相同的一处

内存空间，类变量共享，所有的对象的类变量是相同的一处内存空间，直到程序退出，才释放

内存空间；

另外如果改变其中一个对象的类变量，其它的类变量也就改变了，因为共用一块内存空间。

综上所述，易得，可以通过类变量来访问类名所在的变量，因为空间固定，且由类而来，而实例变量只能通过对象来访问，

因为它们对象在不同的内存空间，所以要精确到具体的对象名。

4)static内部类

static内部类是指被声明为static的内部类，它可以不依赖于外部类的实例对象而被

实例化，而通常的内部类需要外部类实例化后才能被实例化，静态内部类不能与外部类有相同的名字，不能访问

外部类的普通成员变量，只能访问外部类中的静态成员和静态方法。

public class Outer {
    static int n=5;
    static class Inner {
        void accessAttrFromOuter() {
            System.out.println("Inner:Outer.n=" + n);
        }
    }
        public static void main(String[] args) {
            Outer.Inner nest=new Outer.Inner();
            nest.accessAttrFromOuter();
        }

}

　　

内部类才能够用static修饰，还有静态变量或者说类变量要定义在开头；