BlogJava-LittleRain-随笔分类-SL-275学习笔记

SCJP_InnerClass

小雨不打伞 — Fri, 29 Dec 2006 03:58:00 GMT

      嵌套类的类名必须与包装它的外部类区别，且嵌套类的类名仅仅可以作用于定义范围中。方法中定义类，其类名名就只能出现在方法中。

      定义在方法中的嵌套类只能使用定义为final的局部变量，不可以使用方法中的非静态变量。

      嵌套类可以使用的变量种类包括：类变量、实例变量、final局部变量。
      嵌套类同样具有所有的访问控制权限。高级类属性：
      嵌套类可以是abstract类
      嵌套类可以是接口，被其它嵌套类实现。

      定义为static的内部类将成为顶级类(top-level)。它们不依赖于外部类的对象而生成，所以不可以访问外部类的对象成员。
      非static内部类不能定义static成员

内部类的两种创建方式：
a)在带有innerClass的OuterClass的main()方法中的新建方式：Inner inner=new Inner();
b)在OuterClass以外的其它类中的创建方式：Outer.Inner inner=new Outer().new Inner();

小雨不打伞 2006-12-29 11:58 发表评论

SL-275(八)：异常和断言

小雨不打伞 — Wed, 27 Dec 2006 03:51:00 GMT

异常：
异常的分类：可查/不可查

对于异常的处理方法：
1）在内部用try/catch来处理掉
2）继续throws，由调用者去处理

try/catch/finally：

在子类中一个重写的方法只throws父类中声明过的异常或者异常的子类。这只适用于
方法重写而不适用于方法重载。

finally子句除特殊情况(jvm当掉或者调用了System.exit(o))，不然都会在return之前执行

断言：
编译时启用断言：javac -source 1.4 className.java
运行时启用断言：java -ea className

小雨不打伞 2006-12-27 11:51 发表评论

SL-275(七)：高级类特性

小雨不打伞 — Thu, 05 Oct 2006 02:23:00 GMT

1。static关键字

static方法可以访问的变量：局部变量、static属性及其参数。

注：最好使用类名来访问静态方法，不要用对象。

2。final关键字
a)final类：final类不能被继承
b)final方法：final方法不能被覆盖
c)final变量：final变量一旦赋值就不能再改变。

注：1)如果将一个引用类型的变量标记为final，则该变量不能引用任何其他对象。但是，可以改变对象
            的内容，因为只有引用本身是final。
         2)空final变量：一个空final变量应该在构造器种赋值，空final局部变量可以随时在方法体内设置。

3。抽象和接口
a)抽象类：abstract类不能实例化。但是可以创建抽象类引用，但是这个引用只能指向非抽象子类
b)抽象方法：abstract方法没有具体的方法体
注：具有一个或多个抽象方法的类本身必须定义为abstract。
c)接口：
注：1)在接口中声明的所有方法都是public和abstract的
        。。。。。。。所有属性都是public、static和final－－即你只能声明常数属性。
        2)因为接口的抽象方法其访问控制符都已指定是public，所以类在实现这些方法时，必须显示地使用
           public修饰符。

小雨不打伞 2006-10-05 10:23 发表评论

SL275之多态

小雨不打伞 — Wed, 04 Oct 2006 07:33:00 GMT

多态
eg ：
class A{method();}
class B extends A{method();}
A a=new B();
a.method()调用的是B的method()方法。//a.method()执行是，应该看引用a具体指向的内存空间实际存在的是什么对象。从这里来看，引用a所指向的实际内存空间是B的实例。

方法的调用具体决定于运行时，编译器只是检查java语法的正误。

通过对象.属性   的形式来获得属性值时,具体返回的属性值是依赖于对象引用的类型的。

而通过方法来获得对象的属性时,方法调用所返回的属性则决定于具体内存中存在的真正对象。
(attention: 静态的方法这一条不适用)

Eg：
public class TestPoly {
public static void main(String[] args) {

Father1 f=new Child1();
        System.out.println(f.age);//在编译阶段就已经可以确定f.age的值是：45，因为在编译时不会生成对象，
                                              //直接看引用类型即可，所以下面的((Child1)f).age之间看f的类型即可。
        System.out.println(((Child1)f).age);

        f.printAge();//这个需要在运行是通过方法来决定结果，此时，f引用指向的是Child1类型的对象空间，所以调用的是Child类的pringAge()方法，从而得出结果是：90
      ((Child1)f).printAge();
        }
}

class Father1{
int age=45;
public void printAge(){
  System.out.println(age);
}
}

class Child1 extends Father1{
int age=90;
public void printAge(){
System.out.println(age);
}
}

小雨不打伞 2006-10-04 15:33 发表评论

SL-275(六)：类设计

小雨不打伞 — Tue, 03 Oct 2006 08:35:00 GMT

1。四种访问控制符
public   protected    default     private

2。方法覆盖
注意：覆盖方法的可访问性不能比其要覆盖的方法弱。

3。super关键字的用法：
eg：
class B extends A{
      super.println();
      public void println(){}
}

class A{
public void println(){}}

(new B()).println;//此句话会调用super.println()，这个时候调用这个方法的对象是new B()对象。

4。instanceof运算符

5。对象类型转换
# 始终允许类层次中向上转换，事实上，这种转换不需要转换运算符。可以由简单的赋值完成。
eg：class B extends A
转换示例：A a=new B();// 将类B转换成类A;如果这样转换将产生错误：B b=new A();

#对于向下转换，编译器要求转换至少必须是可能的。
#如果编译器允许转换，则在运行时检查对象类型。

6。构造器
子类从父类可以继承所有的变量和方法，但它不能继承构造器。
调用构造器时，总是先递归调用父类的构造器。
在构造器中使用super和this关键字时，必须放在构造器的第一行。

7。Object类的几个方法
注：如果覆盖Object的equals方法，都应该覆盖hashCode方法来保证相同对象的hashCode值相同。

8.Wrapper类
8种基本类型对应8种包装类
J2SE5.0的自动装箱基本类型：
eg：
int pInt=420;
Integer wInt=pInt;//不需要使用这样的语句：Integer wInt＝new Integer(pInt);
intp2=wInt;

9。varargs
eg：public void sum(int...nums)<===>public void sum(int[] nums)

scjp：
1）子类不能继承父类的构造器
2）构造器中调用this和super语句，则必须放在构造器中的第一句

小雨不打伞 2006-10-03 16:35 发表评论

SL-275(五)：数组

小雨不打伞 — Mon, 02 Oct 2006 11:35:00 GMT

1。使用增强的for循环(jdk1.5)
int[] list=new int[3];//此时list数组已经初始化，每个元素为0；
for(int element：list)
{
System.out.println(element);
}
Console：
0
0
0

上述的for语句等价于：
for(int i=0;i{
System.out.println(list[i]);
}

2。数组的复制
使用System.arraycopy(...)函数；

小雨不打伞 2006-10-02 19:35 发表评论

SL-275( 四)：表达式和流程控制

小雨不打伞 — Mon, 02 Oct 2006 06:31:00 GMT

1。变量及其初始化
两种变量：基本变量和引用类型变量。
变量的声明位置：方法内或者方法外。

变量的初始化：
使用变量前必须初始化。
如果代码给一个堆栈变量赋值，编译器就很容易检查此变量；当开始执行方法时，已经为this引用和方法参数赋了值。

对于堆的对象属性，为了保证这一原则，要求编程人员为构造器赋一个初值，如果没有的话，编译器会为其赋缺省值。

2。移位运算符
>> >>>：>> 带符号
<<<：a<<
3。用＋运算符进行字符串连接
注：非String对象要转换为等价的字符串时使用它的toString()成员函数。

4 。switch语句
switch语句的表达式必须是和int类型相容的表达式，byte、short和char类型会升级。（包括枚举类型）
而对浮点和long表达式或对象引用（包括字符串）是不允许的。
注：可以使用rutrun代替break语句
如果switch语句是在循环中，continue语句会使执行跳出switch结构

小雨不打伞 2006-10-02 14:31 发表评论

SL-275(三)：标识符、关键字和数据类型

小雨不打伞 — Mon, 02 Oct 2006 03:18:00 GMT

1。构造和初始化对象
eg：MyDate my_birth=new MyDate(28,9,2006);

my_birth |    0x01abcdef|----------|
                                                       |
day        |                   28|<- -------|
month     |                     9|
year        |               2006|

MyDate my_birth只是声明一个引用，未分配任何内存空间
new MyDate(28,9,2006)声明一块内存空间并进行数据初始化
my_birth=new MyDate(28,9,2006);将引用指向已分配的内存空间，建立两者之间的关系

2。Java语言总是使用传值调用
即：java编程语言支持按值传递参数的指针。
eg：public static void chV(double x)//无法工作的
       {
            x=x*3;
         }
然后我们调用方法：
double y=10;
chV(y);
结果之中y还是10；

这样来理解执行过程：
public static void chV(y)
       {double x;
            x=y=10;
            x=x*3;
         }//方法结束，局部变量x销毁；

注意：当用对象的引用作为参数传递时可以改变对象的状态，因为传递进来的引用参数和临时引用指向了
            同一个对象（即同一片内存空间）。

scjp：
几个容易忘记的关键字：const、enum、native、synchronized、transient、volatile
注意：true和false是Boolean字符，null也是字符，都不是关键字。

3。关于String
java中一个对象的地址用如此方法返回： System.identifyHashCode(Object  a);

小雨不打伞 2006-10-02 11:18 发表评论

SL-275(二)：面向对象编程

小雨不打伞 — Wed, 27 Sep 2006 10:46:00 GMT

1。java类、方法、属性的声明

2。信息隐藏：对于一个对象的属性应该对外进行隐藏，通过提供getXyz()和setXyz()的存取方法来访问。
    好处：可以更改类内部的结构，而客户端代码却不用改变。并且可以在方法中对数据进行验证处理。

eg：public class MyDate{
        private int limitDays=30;
//当limitDays更改为40或者其他天数时，客户端依旧使用的时getLimitDays(),不用修改。
         public int getLimitDays()
      {return limitDays;}

//在方法中对数据进行验证处理。
         public boolean setLimitDays(int days)
{limitDays=days;}
}

3。缺省构造器
注意：
      每个类都有一个默认的构造器。如果不编写构造器，Java编程语言将提供一个缺省的构造器。这个构造器不带参数并且为空。
      但是如果自己在这个类中添加了任何构造器，那么原来提供的构造器将不在起作用。
eg：1)Class A{}//new A()－－－－正确
Class A{
public Class(){int a;}
}//此时再调用new A()就会产生编译器错误。

4。源文件布局
      任何导入语句必须位于所有类声明之前。如果使用包声明，则必须位于类声明和导入语句前。
      源文件的名称必须与该文件的公有类声明和名称相同。原文件可以包含多个类声明，但是只有一个类可以被声明为公有的。如果源文件不包含公有类声明，那么源文件的名称不受限制。

5。import语句
注意：import语句不会导致编译器将任何附加内容加载到工作内存中(与C和C++的include 语句有很大不同)。并且无论是否使用通配符(*)，import语句都对输出类文件及运行时性能都没有任何影响。

小雨不打伞 2006-09-27 18:46 发表评论

SL-275( 一)：入门

小雨不打伞 — Sat, 23 Sep 2006 04:27:00 GMT

1。什么是JVM？
JVM：在真是机器中用软件来模拟实现的一种虚拟的机器。 //貌似和虚拟机差不多。
            JVM运行的代码存储在.class文件中。
            字节码是JVM的机器代码指令。
            不管是Java技术开发工具还是能运行Applet的Web浏览器，都有一个JVM的实现。

2。java程序是如何运行起来的？
不实用jit：
编译：原文件（编译:javac）----->字节码（存储在.class文件中)
运行：java（将字节码装在进类装载器)------>字节码校验------->解释器执行----->运行时--->硬件

使用JIT：   编译与直接用jre相同，运行时：会将解释器与运行时合并用JIT代码生成器来完成--->硬件

小雨不打伞 2006-09-23 12:27 发表评论