2016.10.13一些重要关键字的总结





一.重点分析关键字:
   1.访问权限修饰符:public private protected default

      四个权限从大到小依次排列:public protected default private

	public	protected	default	private
同一个类	true	true	true	true
同一个包	true	true	true	false
子类	true	true	false	false
不同包中	true	false	false	false

在不同包下面只有public与protected可以访问,而且protected必须是继承关系才能够访问.

   2.this/super:

       this关键字代表了所属函数的调用者对象.

       super关键字代表了父类空间的引用

       super关键字的语法:

            (1).子父类存在同名的成员时,可以用super关键字访问父类的成员.

            (2).可以通过super关键字调用指定的父类的构造方法.

       super关键字调用父类方法要注意的事项:

            (1).super关键字调用父类的构造函数时,该语句必须要是子类构造函数中的第一个语句.

            (2).super与this不能同时出现在同一个构造函数中调用其它的构造函数,因为两个语句都需要放在第一个语句.

例如:

package org.lxh.demo;

class Fu{

    int x = 10;

    String name;

    public Fu(){

       System.out.println("父类无参的构造方法被调用!");

    }

    public Fu(Stringname){

       this.name = name;

       System.out.println("父类带参的构造方法被调用!");

    }

    public void eat(){

       System.out.println("爸爸吃薯条");

    }

}

class Zi extends Fu{

   int x = 20;

   public Zi(String name){

      super(name); //指定调用父类带一个参数的构造方法

      System.out.println("子类带参的构造方法被调用!");

   }

   publicvoid print(){

      System.out.println("x="+super.x);

   }

   public void eat(){

      System.out.println("儿子吃龙虾");

   }

}

public class lvjiakai{

    public static void main(String[] args){

    Zi z = new Zi("狗娃");

    z.print();

    }

}

此程序的输出结果:

父类带参的构造方法被调用!

子类带参的构造方法被调用!

x=10

  3.final(最终的):

        final关键字的用法:

            (1).final关键字修饰一个基本类型的变量时,该变量不能被重新赋值,第一次的值就是最终的值.

            (2).final关键字修饰一个函数时,该函数不能被重写.

            (3).final关键字修饰一个类时,该类不能被继承.

例如:

package org.lxh.demo;

class Fu{

    int x = 10;

    String name;

    public Fu(){

       System.out.println("父类无参的构造方法被调用!");

    }

    public Fu(String name){

       this.name = name;

       System.out.println("父类带参的构造方法被调用!");

    }

    public void eat(){

       System.out.println("爸爸吃薯条");

    }

}

class Zi extends Fu{

   int x = 20;

   public Zi(String name){

      super(name); //指定调用父类带一个参数的构造方法

      System.out.println("子类带参的构造方法被调用!");

   }

   public void print(){

      System.out.println("x="+super.x);

   }

   public void eat(){

      System.out.println("儿子吃龙虾");

   }

}

public class lvjiakai{

    public static void main(String[] args){

    Zi z = new Zi("狗娃");

    z.print();

    }

}

此程序的输出结果:

父类带参的构造方法被调用!

子类带参的构造方法被调用!

x=10

package org.lxh.demo;

class Circle{

    double r;

    finaldouble pi = 3.14;

    public Circle(double r){

    this.r = r;

    }

    public final void getArea(){

    System.out.println("圆形的面积是:"+r*r*pi);

    }

}

public class lvjiakai extends Circle{

    public lvjiakai(double r) {

    super(r);

    }

   public static void main(String[] args){

          lvjiakai c = new lvjiakai(4.0);

          c.getArea();

    }

    public void getArea(){

    System.out.println("我是圆...");

    }

}

此程序报错了!

   4.static(静态修饰符):

        使用前提:如果有数据需要被共享给所有所有对象使用时,那么就可以使用static修饰.

        静态成员变量的访问方式:

            方式1:使用对象进行访问.

                     格式:对象.变量名

            方式2:只基金使用类名进行访问.

                     格式:类名.对象名

        静态成员方法的访问方式:

            方式1:使用对象进行访问.

                     格式:对象.静态函数名

            方式2:直接使用类名进行访问.

                     格式:类名.静态函数名

        使用静态函数要注意的事项:

             (1).静态函数可以使用类名或者对象进行调用,而非静态函数只能使用对象进行调用.

             (2).静态函数可以直接访问静态成员,但是不能直接访问非静态的成员,因为静态函数调用时对象可能还没有创建,此时就不存在非静态的成员变量.

             (3).非静态函数可以调用静态与非静态的成员,因为非静态函数必须要由对象调用,当对象存在时,静态函数必然已经存在.

        静态数据的生命周期:静态的成员变量数据是优先于对象存在的.

        静态代码块:static{

                           }

        静态代码块是在对应的字节码文件加载到内存时就执行的!

例如:

package org.lxh.demo;

class Baby{

   int id;

   String name;

   //构造代码块

   {

      cry();

   }

   public Baby(int i,String n){

      id = i;

      name = n;

   }

   public Baby(){

   }

   public void cry(){

      System.out.println(name+"哭!!");

   }

}

public class lvjiakai{

   public static void main(String[] args){

      new Baby(110,"狗娃");

   }

}

此程序的输出结果:null哭!!

        构造代码块:{

                           }

        构造代码块的作用:给对象进行统一的初始化.

        注意构造函数、构造代码块、成员变量赋值的顺序:

             (1).一旦经过java编译器编译后,构造代码块的代码就会被移动到构造函数中执行,构造函数中搞得代码是最后执行的.

             (2).成员变量的显式初始化与构造代码块的代码是按照当前代码的真实先后顺序执行的.

        如果有静态代码块,则静态代码块还会优先于构造代码块执行,类只被加载一次时,静态代码块必然只执行一次.

综合举例:

package org.cn.lxh;

public classTest{

   public static void main(String[]args){

       Student stu1 = new Student();

       Student stu2 = new Student();

       stu1.play();

       Student.study();

    }

}

package org.cn.lxh;

public class Student{

   public String address;

   public static String name;

   static{

       System.out.print(1);

   }

   {

       System.out.print(2);

   }

   public Student(){

       System.out.print(3);

   }

   public static void study(){

       System.out.print(4);

   }

   public void play(){

       System.out.print(5);

   }

}

此程序的输出结果:1232354

因为Student类只加载了一次,所以静态代码块只执行了一次.

PS:本人初学java,有很多地方有不足,希望博友们多多指点!!!