java基础知识总结

■final     ◆ 修饰的变量

类中声明为final的变量，有两种初始化方式：

1、声明时就初始化。

2、2。在类的构造方法中初始化

        初始化以后就不能在修改了

        ◆ 修饰的方法

        不能被子类重写，但可以被本类方法重载

        ◆ 修饰类

        我不会继承这个类，  

■static    ◆ 修饰的变量

类中声明为static的变量，在类的第一次实例化就存在于内存，以后的实例化就不会重复产生内存空间了

        ◆ 修饰的方法

        只能操作本类的静态成员属性

 

■static final◆ 共同声明的成员属性，在申明时就要初始化。

`  

■public    ◆ 类中的成员属性

              可以被包内包外的的类的实例化对象方法使用(类A中有public方法，类B和A在同一包中，类B通过在自己的实例化对象的方法中在申明类A的对象对类A的方法进行调用)

■protected ◆类中的成员属性

      可以被包外继承本类的类的实例化对象使用和包内的类的实例化对象方法使用

■private   ◆类中的成员属性

             只能被本类的成员方法使用

■interface   ◆功能的集合，但方法都没有实体，默认都是public 方法和默认的public final 属性。

■abstract   ◆本身不能被实例化，但继承它的子类在实例化自己的时候会初始化一些抽象类的属性。

■多态        ◆继承了同一接口的不同类。在声明时声明成接口类型，在实例化时可以实例化成这几个不同类(但实例化后的对象只能使用接口本身的方法)

■继承       ◆子类可以继承父类的全部protected和public的方法和属性

        例子：

        com.org.bluedot包中一个类

        public class A

{

  protected int age;

}

com.org.bluedot.test包中一个类

 

import com.org.buledot.*;

public class B extends A

{

  public static void main(String [] args)

  {

      B b = new B();

      b.age;      //可以这样引用

      A a = new A();

      a.age;      //不可以这样引用

}

}

protected类型的成员属性和方法只能有本包内的方法操作和外包的子类对象操作（外包子类中new的父类对象不能操作父类的protected）

■内部类 ◆内部类的实例化发生于外部类已被实例化以后可有两种实例方法

１、在外部类实例化以后，用实例化的对象（My1.MyIn2 a = a0.new MyIn2();）在实例化内部对象。

        ２、在外部类的方法中加入实例化内部类。

内部类和外部类可以互相操作对方的private的成员属性和成员方法,不用this可直接操作，但在内部类前加上static后，内部类就不能访问外部类的属性了

        内部类之间可以继承

        内部类的public,private,protected修饰符同外部类的属性定义权限一样！

        public的内部类可以被实例化了外部类的所有类实例化

        private的内部类只能被本类的对象实例化

protected的内部类能被本包中实例化了外部类的所有类实例化和外包中继承了该外部类的实例化对象实例化

        内部类隐藏的是它的类型！

        ◆例子

       

class My1

{

  // 帮助类，工具类，辅助类

  private class MyIn

  {

      private int m;

      public void f()

      {

          a++;  //可访问外部

          System.out.println("MyIn...f");

      }

  }

 

  private class MyIn3 extends MyIn

  {

      public void f()

      {

          super.f();

          System.out.println("MyIn3 ... ...");

      }

  }

 

  //复杂内部类

  public class MyIn2

  {

      public void f()

      {

          a++;  //可访问外部

          System.out.println("MyIn...f");

      }

  }

 

  public static class MyIn4

  {

      //a++;  // 没有外部对象的指针

      public void f()

      {

          System.out.println("MyIn4...f");

      }

  }

 

  private int a;

 

  public void add()

  {

      a++;

  }

 

  public void show()

  {

      System.out.println(a);

      MyIn x = new MyIn();

      x.f();

      x.m++;  //外部可访问内部类

  }

 

  public void g()

  {

      //MyIn a = new MyIn3();

      //a.f();

     

      // 只用一次的类不需要定义

      MyIn x = new MyIn() {

          public void f(){

              super.f();

              System.out.println("Ni Ming");

          }

      };

      x.f();

  }

}

 

public class InnerC

{

  public static void main(String av[])

  {

      /*

      My1 a = new My1();

      a.add();

      a.show();

      a.show();

      */