java笔记第八章之三个修饰符

一，三个修饰符

static final abstract

@，static

1，static 是静态修饰符，所修饰的属性属于全类共有，这个修饰符不能修饰局部变量

  修饰的三种组件：属性 方法 静态代码块

2,static 修饰的静态变量要用类名访问

static int age;

String name;

例如：People people1=new People();

People.age=20;

people1.name="zhang san";

3,两个名词：实例变量：不用static修饰的变量叫实例变量

    类变量：用static修饰的变量叫类变量

4，什么是类加载：当java虚拟机要使用一个对象时，先从电脑硬盘中读取.class当中的内容，将.class中的内容加载到虚拟机中，类加载只发生一次，一次加载就ok，内容会存到jvm内存中，

  类变量赋值是发生在类加载时，创建对象之前，不是发生在调用构造函数的时候（实例变量赋值是发生在调用构造函数时）

注意：1，static修饰的方法称为静态方法

2，静态方法可以通过类名调用/普通方法必须创建对象

3，非静态方法无论属性和方法是否是静态的都可以访问

4，静态方法只能访问静态属性和静态方法//类变量和类方法出现在创建对象之前，类加载的时候，这时没有对象，所以不能访问

5，静态方法内不能有this，（因为this代表当前对象，这时候是发生在类加载的时期，对象还没创建）

6，非静态方法只能覆盖非静态方法，不能覆盖静态方法

7，静态方法只能覆盖静态方法，不能覆盖非静态方法（静态方法覆盖后没有多态）

 class super{

public static void m(){

system.out.println("this is super");

}

}

 class sub extends super{

public static void m(){

system.out.println("this is sub");

}

}

public class test{

public static void main(String args[]){

super.m()//此时打印出 this is super 因为静态方法覆盖没有了多态

}

}

5，当出现静态代码块时，静态代码块先执行   {

system.out.println("123");//这是一种代码块

} 

public class TestStatic{

static{

system.out.println("this is static")

}

}

@final

#用法：1，用在类上，不能被继承，没有子类 2，用在方法上，不能被覆盖 3，用在变量上，不能被修改（属性，局部变量）

#修饰的是： 变量，方法，类（Static 不能修饰类）

#final MyClass m1=new MyClass();

 m1.value=20;

 m1.value=30;//正确 因为m1是引用对象存放的首地址，不能改变，但不是对象的不能变

 m1=new MyClass()//错误

#，final修饰属性时，必须对属性赋值或提供构造方法对属性赋值、

(1),class MyClass(){    这一种不可以创建对象，因为创建对象时，jvm会给I赋初始值为0，这个值不可以改变

final int I;

}

(2),class MyClass(){

final int I=10;//这种可以，定义时赋好初始值

}

(3),class MyClass(){

final int I;

public MyClass(int I){//这种是通过构造函数赋值，因为构造函数只会被执行一次，就保证final变量只会被赋值一次，不能混合（2）和（3），因为对象被创建的步骤

  this.I=I;               是  分配内存-》初始化属性-》调用构造函数  （2）和（3） 比较，（3）比较好，每创建一个对象都可以赋予不同的值，而一方式每创建对象后里面的值都是固定的

}

}

经常见static final int I=20；加个static 减少了内存浪费；所以用final时最好加上static，

@abstract 

#主要修饰：类和方法

#用法：1，用在方法上，没有方法体  2，用在类上不能被实例化

# abstract 修饰的类叫做抽象类，抽象类可以用于声明，但不允许创建对象

例如 abstract Class MyClass{

MyClass m1; 变成这样就可以了 MyClass m1;

m1=new MyClass();//这种是错误的 m1=new MyClass(){}//这时变成了匿名类

#,抽象类的好处：抽象类可以被子类继承，从而创建子类对象，抽象类实际上就是被继承的；

#；抽象方法：public abstract void test1(); 此方法只有生命，没有实现

#注意：拥有抽象方法的类必须是抽象类（因为不是抽象类就可以被创建对象，创建完就可以调用抽象方法，但方法没有方法体）

#；抽象类不一定就有抽象方法；

#,1，抽象方法在非抽象类中必须被实现 2。，非抽象方法如果子类重写了，那么就是覆盖

#，对于抽象类只有两种结局：1是被实现，2继续被抽象

#，抽象的作用（为什么要用抽象类）

答：不是抽象类的话，类中的方法要带方法体{return o} 这些，当子类继承时要覆盖父类方法，这和继承没什么区别，主要是抽象类中省去了{return 0}

# --------------------------------------------------

      继承       多态 封装

  非抽象  定义了行为和默认实现 |选择性重写 | 支持（覆盖）| 可以用private修饰

  是抽象   之定义行为          | 必须重写  |     支持       |不可以用private