黑马程序员----基础加强2

------- android培训、java培训、期待与您交流！ ----------

 

>>java5静态导入与编译语法设置

此为1.5特性。

 

import语句

可以导入一个类或某个包中的所有类。

import static语句

导入一个类中的某个静态方法或所有静态方法。

 

Eg：求两个数最大值和两个数相减绝对值

Java提供的一个叫math的类，其中有一些静态方法帮助我们做一些数学运算。

 

package cty.show;

 

public class Temp {

 

         publicstatic void main(String[] args) {

                   System.out.println(Math.max(3, 6) );

                   System.out.println(Math.abs(3-5) );

         }

}

 

由于max和abs是Math中的静态方法，我们可以使用静态导入，从而不用写类名。

 

package cty.show;

 

import static java.lang.Math.max;//导入一个方法

import static java.lang.Math.*;//导入所有方法

 

public class Temp {

 

         publicstatic void main(String[] args)

{

                   System.out.println(max(3, 6) );//不用再写类名

                   System.out.println(abs(3-5) );//不用再写类名

 

         }

}

 

         但是有人使用静态导入报错。原因可能是preference中将JDK配置成1.5以下的版本了。

 

 

 

 

>>可变参数

此为1.5特性。

 

一个方法接收的参数如果是不确定的，比如add（1，2，3）又add（1，2，3，4）。就可以用可变参数实现。

 

特点：

1）  只能出现在参数列表的最后

2）  “…”位于变量类型和变量名之间，前后有无空格皆可以

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

Eg:使用可变参数传入多个参数

package cn.com.cty;

 

public class VariableParameter {

 

         publicstatic void main(String[] args) {

                  

                   intsum = add(1,2,3,4,5);

                   System.out.println(sum);// 结果输出15

         }

        

         publicstatic int add(int first, int ... other)

         {

                   intsum = 0;

                  

                   sum= first;

                  

                   for(intx=0 ; x<other.length ; x++)

                   {

                            sum= sum + other[x];

                   }

                  

                   returnsum;

         }

}

 

 

 

 

>>overload和override

override（重写）

1、方法名、参数、返回值相同。

2、子类方法不能缩小父类方法的访问权限。

3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

4、存在于父类和子类之间。

5、方法被定义为final不能被重写。

overload（重载）

1、参数类型、个数、顺序至少有一个不相同。 

2、不能重载只有返回值不同的方法名。

3、存在于父类和子类、同类中。

 

Eg:错误例子

class Father {

         publicvoid show() { }

}

 

class Children extends Father {

         /*publicint show() { //编译报错

                   return1;

         }*/

        

         publicvoid show(){  }  //允许

        

         publicvoid show(int a){  }  //允许

 

public voidshow(int a, String str){  }  //允许

        

         publicvoid show(String str, int a){  }  //允许

}

 

 

 

 

>>接上上个例子，说明增强for循环

Eg：

……………………

/*

for(int x=0 ; x<other.length ; x++)

{

         sum= sum + other[x];

}*/

                  

for(int num : other)

{

         sum+= num;

}

……………………

说明：

1）  迭代变量必须在for（）的括号中定义！

2）  集合变量可以是数组或实现了iterable接口的集合类

 

在sun公司的java语言规范《langspec》中有关于增强for循环的说明章节：

14.14.2 Theenhanced for statement

The enhanced forstatement has the form:

EnhancedForStatement:

for ( VariableModifier_sopt TypeIdentifier: Expression) Statement

………………

 

 

 

 

>>基本数组的自动拆箱和装箱

1.5特性。

 

自动装箱：

Integer num = 12; //12是int类型

自动拆箱：

Sop(num + 12); //Integer是不支持“+”的

 

 

 

>>基本数据类型的对象缓存以及享元模式

Eg:说明例子

……………………

Integer num1 = 12;

Integer num2 = 12;

Sop(num1 == num2);  //true

 

Integer num3 = 129;//注意数字

Integer num4 = 129;

Sop(num3 == num4);  //false

 

Integer num5 = Integer.valueOf( 12 );

Integer num6 = Integer.valueOf( 12 );

Sop(num5 == num6);  //true

……………………

说明：

1）  num1和num2很容易和以下代码对比：

Stringstr1 = new String("abc");

Stringstr2 = new String("abc");

System.out.println(str1== str2); //输出false

但是却输出true，因为有自动拆装箱。

 

2）  如果在一个字节之内（-128~127），那么就缓存起来，如果超过，就是新建对象了。这样做是因为认为小的数字容易经常使用。此称为享元模式。

 

3）  使用valueOf方法将一个基本类型的整数变成对象。同理，如果传入不是12而是129，那么就是false。

 

享元模式（英语：FlyweightPattern）是一种软件设计模式。它使用共享物件，用来尽可能减少内存使用量以及分享资讯给尽可能多的相似物件；它适合用于当大量物件只是重复因而导致无法令人接受的使用大量内存。

 

 

 

 

>>枚举

         枚举就是要让某个类型的变量的取值只能为若干个中的一个，否则，编译报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。

 

         普通类如何实现枚举功能

1）  私有的构造方法

2）  每个元素分别用一个公有的静态成员变量表示

3）  可以有若干公有方法或抽象方法，例如，要提供nextDay方法必须是抽象的。使用抽象方法定义nextDay就将大量的if-else语句转化成一个个独立的类。

 

Eg：使用普通类模拟枚举

package cn.com.cty;

 

public class SimEnumDemo {

        

         privateSimEnumDemo(){

                   //私有化构造函数

         }

        

         //定义常量

         publicfinal static SimEnumDemo SUN = new SimEnumDemo();

         publicfinal static SimEnumDemo MON = new SimEnumDemo();

         publicfinal static SimEnumDemo TUE = new SimEnumDemo();

         publicfinal static SimEnumDemo WED = new SimEnumDemo();

         publicfinal static SimEnumDemo THU = new SimEnumDemo();

         publicfinal static SimEnumDemo FRI = new SimEnumDemo();

         publicfinal static SimEnumDemo SAT = new SimEnumDemo();

        

         publicstatic void main(String[] args) {}

        

         //提供方法查询下一天

         publicvoid nextDay()

         {

                   //…………………………

         }

        

         //提供方法输出当天是星期几

         publicString toString()

         {

                   return"";//暂时无字符

         }

}

 

class SimEnumTest

{

         publicvoid test()

         {

                   //即，只能调用已经定义好的常量，七个常量以外的数据时不可能的

                   SimEnumDemosim = SimEnumDemo.MON;

         }

}

 

 

Eg：使用普通类模拟枚举（抽象类）

package cn.com.cty;

 

public abstract class SimEnumDemo {

        

         privateSimEnumDemo(){

                   //私有化构造函数

         }

        

         //定义常量，且因为抽象类是不能创建对象的，只能在子类创建，这里用匿名内部类来创建

         //此匿名内部类也就是SimEnumDemo的子类

         publicfinal static SimEnumDemo SUN = new SimEnumDemo(){

 

                   @Override

                   publicSimEnumDemo nextDay() {

                            returnMON;

                   }

                  

         };

         publicfinal static SimEnumDemo MON = new SimEnumDemo(){

 

                   @Override

                   publicSimEnumDemo nextDay() {

                            //TODO Auto-generated method stub

                            returnSUN;//这里只是演示

                   }

                  

         };

         /*publicfinal static SimEnumDemo TUE = new SimEnumDemo();

         publicfinal static SimEnumDemo WED = new SimEnumDemo();

         publicfinal static SimEnumDemo THU = new SimEnumDemo();

         publicfinal static SimEnumDemo FRI = new SimEnumDemo();

         publicfinal static SimEnumDemo SAT = new SimEnumDemo();*/

        

        

        

         //提供抽象方法查询下一天

         //有人不喜欢使用一般方法中if-else来判断，

         //所以就想上面代码所示，使用抽象类来写每一个nextDay

         publicabstract SimEnumDemo nextDay();

        

        

         //提供方法输出当天是星期几

         publicString toString()

         {

                   return"";//暂时无字符

         }

        

         publicstatic void main(String[] args) {}

}

 

class SimEnumTest

{

         publicvoid test()

         {

                   //即，只能调用已经定义好的常量，七个常量以外的数据时不可能的

                   SimEnumDemosim = SimEnumDemo.MON;

         }

}

 

 

 

 

>>枚举的基本应用

Eg：入门例子

package cn.com.cty;

 

public class EnumDemo {

 

         publicstatic void main(String[] args)

         {

                   WeekDayweekday0 = WeekDay.SUN;//注意，这是一个对象

                   System.out.println(weekday0);//自动实现toString

                   System.out.println(weekday0.name());//名称

                   System.out.println(weekday0.ordinal());//排位，0开始

                   System.out.println(weekday0.getClass());//得到自身的类

                  

                   /*输出：

                   SUN

                   SUN

                   0

                   classcn.com.cty.EnumDemo$WeekDay*/

                  

                   //枚举本身的静态方法

                  

                   //valueOf（）,如果传入字符串，返回实例对象

                   WeekDayweekDay1 = WeekDay.valueOf("MON");

                   System.out.println(weekDay1);  //输出MON

                  

                   //values（），得到所有元素的数组

                   WeekDay[]weekDayArr = WeekDay.values();

                   System.out.println(weekDayArr.length);//输出7

                  

                  

         }

        

         publicenum WeekDay

         {

                   SUN,MON,TUE,WED,THU,FRI,SAT;//这里可以有分号，也可以没有

         }

}

 

 

 

 

>>带有构造方法的枚举

 

1）元素列表必须在所有代码之前（包括构造函数），这个时候元素列表就必须有分号；

2）构造方法必须是私有的

3）枚举元素XX和XX()是一样的，都是调用默认（无参）的构造方法

 

Eg：基本要求说明

package cn.com.cty;

 

public class EnumDemo {

 

         publicstatic void main(String[] args)

         {

                   WeekDayweekDay0 = WeekDay.SUN;

                   System.out.print(weekDay0);

                  

                   /*

输出：

                   first  first first  first  first first  first  SUN

                   只要是调用了WeekDay，那么所有对象就都初始化，

                   因为，通过“普通类模拟枚举”的例子可以知道，它们都是静态的

*/

         }

        

         publicenum WeekDay

         {

                   //必须在所有代码前，需要有分号

                   SUN,MON,TUE,WED,THU,FRI,SAT;

                  

                   //先调用哪个？看输出

                   privateWeekDay()

                   {

                            System.out.print("first  ");

                   }

                  

                   privateWeekDay(int day)

                   {

                            System.out.print("second  ");

                   }

         }

}

 

 

Eg：调用有参数的构造函数

package cn.com.cty;

 

public class EnumDemo {

 

         publicstatic void main(String[] args)

         {

                   WeekDayweekDay0 = WeekDay.SUN;

                   System.out.print(weekDay0);

                  

                   /*输出：

                   second  first first  second  first first  first  SUN

                   */

         }

        

         publicenum WeekDay

         {

                   //在后面加上括号，决定调用哪个构造方法

                   SUN(0),MON(),TUE(),WED(3),THU,FRI,SAT;

                  

                   //加上括号后调用哪个？看输出

                   privateWeekDay()

                   {

                            System.out.print("first  ");

                   }

                  

                   privateWeekDay(int day)

                   {

                            System.out.print("second  ");

                   }

         }

}

 

 

 

 

>>带有抽象方法的枚举

 

         枚举相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。

 

         枚举只有一个成员时，可以作为一种单例的实现方式。

 

Eg：说明例子

package cn.com.cty;

 

public class TrafficLampEnum {

 

         publicstatic void main(String[] args) {

                  

                   TrafficLamplamp = TrafficLamp.GREEN;

                   System.out.println(lamp.nextLamp());

                  

                   /*

                    * 输出：

                    * YELLOW

                   */

         }

        

         //内部类可以有四种类型（可以有public类有木有），和内部方法是平级的

         publicenum TrafficLamp

         {

                   //实现抽象方法，指定构造函数

                   RED(30){

                            publicTrafficLamp nextLamp()

                            {

                                     returnGREEN;

                            }

                   },

                   //实现抽象方法，指定构造函数

                   GREEN(45){

                            publicTrafficLamp nextLamp()

                            {

                                     returnYELLOW;

                            }

                   },

                   //实现抽象方法，指定构造函数

                   YELLOW(5){

                            publicTrafficLamp nextLamp()

                            {

                                     returnRED;

                            }

                   };

                  

                   //抽象方法，返回下一个灯是什么

                   publicabstract TrafficLamp nextLamp();

                  

                   //指定每个灯点亮时间

                   privateint time;

                   privateTrafficLamp(int time)

                   {

                            this.time= time;

                   }

         }

}