java知识补充

一、数组与内存控制

 

1、数组初始化：（针对数组对象而不是数组变量）

  分配内存空间+指定初始值

  *静态初始化：

  *程序员指定元素初始值，系统指定数组长度

  String[]  str = {

“aaa”,

“bbb”,

“ccc”

 }

  *动态初始化：

  *程序员指定数组长度，系统指定元素初始值

  String[]  str = new String[5];

  *初始化规则：

  *byte，short，int，long：0

  *float，double：0.0

  *char：‘\u0000’

  *boolean：false

  *引用类型(类，接口，数组)：null

2、引用变量和对象使用区分：

      *引用变量：

    存放在栈中，程序中直接使用

  *对象：

存放在堆中，程序使用时需要通过它访问属性或方法

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

二、对象与内存控制

 

1、java内存管理：

*内存分配：

  创建java对象时，JVM在堆中分配内存空间

*内存回收：

  Java对象失去引用，JVM回收其堆中的内存空间

2、java的变量：

      *成员变量：(类内定义的变量)

    *非静态变量：

 (实例变量)

          *所属：

实例对象

  *内存：

        多份内存

  *访问：

实例对象访问

                                                              *初始化：

a、定义时指定初始值

b、非静态初始化块中

c、构造器中

Class Cat{

   String name;

   Public Cat(String name){

This.name=name;

   }//构造函数

   {

        name=”bbb”;

   }//非静态初始化块

   Int age = 10;//定义时指定

结果:name=bbb age=10

c的执行顺序最后，a和b的执行顺序与其    在代码里的顺序有关

    *静态变量(类变量，static修饰)：

 *所属：

      类

 *内存：

      一份内存

 *访问：

      *类访问

      *实例对象访问(转换为类访问) 

 *初始化：

         a、定义时指定初始值

         b、静态初始化块

         a和b执行顺序与两者在程序中的                         顺序有关

         Public class Cat{

       Static int count = 2;

       Static{

          name=”编程”;

       }

                                                                                                    Static String name=”算法”;    

 }

 结果：name=”算法” count=2   

  *局部变量：

（存储在栈内存中）

*形参：

  方法签名中定义的局部变量，方法调用者为其赋值，方法        结束时消亡

*方法内的：

  在方法内对它初始化(显示赋值)，方法结束时消亡

*代码块内的：

    在方法内对它初始化(显示赋值)，方法结束时消亡

 

3、访问子类对象的实例变量(特例)：

       class Base{

    private int i = 2;

    public Base{

      this.display();     //1

    }

    Public void display(){

       System.out.println(i);

    }

}

    class Derived extends Base{

        private int i = 22;

        Public Derived{

          System.out.println(“Derived”);

        }

        Public void display(){

           System.out.println(i);

        }

    }

当调用new Derived();时，打印为i=0

    因为构造函数中，this指的是调用构造函数的对象，而在1处的 this因为处于父类      的构造函数中，所以this的编译类型为Base,(实际为Derived))当编译类型与运行

    时类型不一致时，引用的变量为父类变量，引用的方法为子类方法，所以调用的是子    类display()方法，此时子类的i为0 ？？？？？？？？？？？？？？？？

 

4、调用被子类重写的方法(特例)：

    class Animal{

       private String desc;

       public Animal{

   this.desc=getDesc();         //1

          }

       public String getDesc(){

           return “animal”;

       }

       public String toString(){

           return desc;

       }

    }

    class Wolf extends Animals{

       private String name;           //2

       private double weight;         //3

           public Wolf(String name,doubleweight){     

    this.name=name;

    this.weight=weight;

          }

          @Override

          public String getDesc(){

               return “name=”+name+”;weight=”+weight;

          }

      }

     执行：new Wolf(“灰太狼”,32.3)

     输出：name=null;weghit=0.0

     1行处的getDesc()是调用子类的方法，而2、3行还未执行

     避免在父类构造器中调用子类重写的方法

 

4、继承中的实例变量和方法：

                          对于一个变量，当通过它访问它所引用的对象时，

                          访问实例变量取决于声明该变量时的类型；

      访问方法时取决于实际对象的类型

5、final修饰符：

  *修饰变量：该变量显示(必须的)指定初始值后，不能对它重新赋值

             *修饰实例变量：

               public class Test{

                   final String var1 =”first”;   //定义时指定

   final String var2;

   final String var3;

       {

         var2=”second”;

        }

        //初始化块中指定

       public Test(){

           Var3=”third”;

       }

  }

*修饰局部变量：(显示赋值)

            局部内部类(包括局部匿名内部类)必须访问final                                  局部变量

Interface IntArray{

    Int product();

}

public class Test{

  public int[]process(IntArray ia;int length){

        int[] result = newresult[length];

        for(inti=0;i<length;i++){

           result[i]=ia.product();

        }

        return result;

}

Public static void main(String[] args){

      final int seed = 5;

      Test t = new Test();

      int[]result=t.process(new IntArray{

      public int product(){

               ReturnMath.random()*seed;

                    }},6);

}

  *修饰方法：该方法不能被重写

  *修饰类：该类不能派生子类                               

     

 

 

 

 

 

 

 

 

 

 

 

 

 

三、常见java集合的实现细节