java基础

下面开始笔记：

一，静态导入

    import语句可以导入一个类或某个包中的所有类

    import static语句导入一个类中的某个静态方法或所有静态方法

      语法举例：

    import static java.lang.Math.sin;

    import static java.lang.Math.*;

 

二，可变参数：不固定的参数

        问题：一个方法接受的参数个数不固定，例如：

          System.out.println(countScore(2,3,5));

          System.out.println(countScore(1,2,3,5));

 

**面试**：overload与override的区别（最好说出深入的，自己的观点）

     overload：重载：在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同，方法体也不相同，最常见

                                       重载的例子就是类的构造函数，可以参考API帮助文档看看类的构造方法

     override：重写：子类的方法覆盖父类的方法，要求方法名和参数都 

     eg：public static int add (int x,int … args)

         {

                int sum = x;

                for（int I = 0;i<args.length;i++）

                {

                   sum += args[1];

                }

                return sum;

}

特点：1）只能出现在参数列表的最后；这个要记住

            2）...位于变量类型和变量名之间，前后有无空格都可以;

            3）调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

 

三，增强for循环

      语法：for ( (可以加上修饰符)type变量名：集合变量名 )  { … } 

      注意事项：迭代变量必须在( )中定义！     集合变量可以是数组或实现了Iterable接口的集合类

      示例：（注释/+Shift）

            for (int arg : args)

            {

                  sum+=arg[1];

            }

      课外：可以多查查SUN公司提供的源代码，看看具体代码怎么写，什么意思。。。

 

四，自动装箱与拆箱

        自动装箱：Integer num1 = 12;

        自动拆箱：System.out.println(num1 + 12);

     细节：a，Integer i1 = 13；

                        Integer i2 = 13；

                        i1==i2；——》true

                  b，Integer i1 = 137；

                        Integer i2 = 137；

                         i1==i2；——》false

                  c，Integer i1 = Integer.valueOf(3)；

                        Integer i2 = Integer.valueOf(3);

                        i1==12——》true

                  d，Integer i1 = Integer.valueOf(231)；

                        Integer i2 = Integer.valueOf(231);

                        i1==12——》false

           当Integer装箱对象时，此时对象是一个字节之内（-128——127）会把它放进敞亮池中，下次建立此对象是直接用，不用在new新的了，可以节省内存，这种做法叫做享元模式。

      享元模式flyweight：当使用的对象使用率较高或属性相同率较大，对象又比较小，把对象存起来，如图标，把同一类型的图标设计成一个

 

五，枚举Emun：

      1，出现的原因：当我们遇到问题如，要定义星期几或性别的变量，该怎么定义？假设用1-7分别表示星期一到星期日，但有人可能会写成int weekday = 0;或即使使用常量方式也无法阻止意外。枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

   示例：1）模拟枚举类

class EnumTest

{

     public static void main(String[] args)

       {

            //int weekday = 7;

                     WeekDay weekday = WeekDay.MON();

                    //此时只能调用在WeekDay中定义好的常量，防止重复的定义

       }

}

//枚举：使用的值（如SUN等）都是在类中固定的，且都是对象

class WeekDay

{

         private weekDay(){}

 

         public finally static WeekDay SUN = new WeekDay();

         public finally static WeekDay MON = new WeekDay();

         public WeekDay nextDay()

        {

                    if(this == SUM)

                   {

                            return MON;

                   }

                   else

                   {

                           return SUN;

                   }

        }

         public String toString()

         {

                     return this==SUN?”SUN’:”MON”;

         }

}

  以上代码的另一种方法，用匿名内部类的形势

abstract class WeekDay

{

        private weekDay(){}

    //由于类是抽象的，不能建立自己的对象，因此我们建立子类对象，并覆盖方法

        public finally static WeekDay SUN = new WeekDay()

        {

                  public WeekDay nextDay()

                  {

                           return MON;

                   }

         };  //通过建立匿名内部类的方法

          public finally static WeekDay MON = new WeekDay()

          {

                     public WeekDay nextDay()

                     {

                               return SUN;

                      }

          }; 

          public abstract WeekDay nextDay()；//由于这里方法抽象化，因此类也要抽象的

          public String toString()

          {

                     return this==SUN?”SUN’:”MON”;

          }

}  //用这种抽象方法定义nextDay就将大量的if，else语句转移成了一个个独立的类，便于观看使代码简化

 

       2）基本的枚举类（也可以叫枚举的应用）

class EumTest

{

         public static void main(String[] args)

        {

                     WeekDay weekday = WeekDay.MON;

                    weekDay.name();   //获取名字

                     weekDay.ordinal()   //自己的排行

                     weekDay.getClass();

                     WeekDay.valueOf(“SUN”);   //把字符串变成WeekDay对象 

                     WeekDay.values();       //返回WeekDay的数组

          }

}

//建立WeekDay的内部类

public enum WeekDay   //枚举的关键字

{

      SUN,MON,TUE,WED,THI,FRI,SAT;（这里的分号可以使用，也可以省略）

       private WeekDay(){}    //枚举的构造方法必须在元素列表之后，且必须是私有的

                                             //调用的时候都是调用第一个方法

       private WeekDay(int day){}；  //在元素后加()如SUN(1)，调用此时的方法

}  //枚举

        3）带有抽象方法的枚举

public enum WeekDay  

{

         SUN(1),MON,TUE,WED,THI,FRI,SAT;  

           //（这里的分号可以使用，也可以省略）

          private WeekDay(){}   

           //枚举的构造方法必须在元素列表之后，且必须是私有的

           //调用的时候都是调用第一个方法

          private WeekDay(int day){System.out.println("frist");} 

           //在元素后加()如SUN(1)，调用此时方法

}   //枚举

        4）如果枚举只有一个对象，就可以用单例的实现方式

new Date（300）{} //new Date的子类，子类的构造方法可以调用父类有参数的构造方法，可以加上参数

 

六，反射

1，Class类：

     1）反射的基石，Java类用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是由这个类的实例对象来确定的，不同的实例对象有不同的属性值。Java程序中的各个Java类，它们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class，要注意与小写class关键字的区别哦。Class类描述了哪些方面的信息呢？类的名字，类的访问属性，类所属于的包名，字段名称的列表、方法名称的列表，等等

     2），定义Class：Class cls1 =字节码1；（当我们在建立对象的时候，会在内存中建立一份字节码）

     3），获取字节码的方式：三个字节码是一样的

             a，Class cls = Date.class;  //建立一份Date文件的字节码

             b，Date d = new Date（）；

                d.getClass（）；      //获取字节码

             c，Class.forName(“java.lang.Date’);   //**面试**：这个方法的作用：返回字节码返回两种，一种是JVM中已经加载了字节码，一

                                                                                               种是没有字节码，现加载到内存中

     4），预定义的Class实例对象：八个基本类型，和一个void类型

              在源程序中出现的类型，都有儿子各自的Class示例对象

     5）方法：isPrimitive（）；   //是否是原始类型字节码

               int.Class = = Integer.TYPE——》true

              数组类型的Class示例对象：Class.isArray()

2，反射定义：反射就是把Java类中的各种成分映射成相应的java类。例如java类的Class类要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

            但是反射会导致系统性能下降。

3，Constructor类（构造方法类）：代表了某个类中的一个构造方法

     1）得到某个类所有的构造方法：

      Constructor [] constructors= Class.forName("java.lang.String").getConstructors();

     2）得到某一个构造方法：

      Constructor constructor =

      Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);

            //确定要获得哪个构造方法，传进构造方法的参数类型的字节码

     示例：用构造方法Constructor实现new String (new StringBuffer(“abc”))

            Constructor constructor1 = String.class. getConstructor(StringBuffer.class);

            String str =（String）constructor1.newInstance(new StringBuffer(“abc”));

           //建立一个参数为StringBuffer类型的String实例

     3）newInstance方法：

           a，在Constructor中的newInstance方法：

                <T> newInstance(Object... initargs)   //带参数

               使用此 Constructor对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

           b，在Class中的newInstance方法：

                <T> newInstance()      //不带参数

                创建此 Class对象所表示的类的一个新实例。简化Constructor创建实例的代码。

 

***查找源代码的方法：找到JDK，在src。zip中在按照包名，类名***