孙鑫JAVA教学视频学习笔记(1-3) (应该是以前叫JAVA无难事吧...)

上一篇 / 下一篇  2009-02-22 16:42:50 / 个人分类:读书笔记

JAVA基础

javac 编译器  -》字节码         >javac hello.java
java 解释器                     >java  Hello      (加载的是Hello类,是由javac产生的字节码类;必须大写头)

所有java程序都是以类来执行的;

.多个class可以编辑到一个.java文件中,但编译后会分别产生各个.class字节码文件;可以将多个.class打包成.jar文件.
.如果在源文件中定义了一个public的class之后,此文件名必须为这个类名; -- 一个源文件中最多只能有一个Public的类

. classpath 设置为 E:/JAVA,.   点代表当前路径
语法:
基本类型
byte -128~+127

boolean 取值: true/false 不能是0,1
while(1)  不能编译
int num[3] JAVA中不能这样定义
必须:
int num[];
num = new int[3];
或者
int num[] = new int[3]

建议的数组定义方式
int[] num;
定义时可以分配元素:
int[] num = {1,2,3}

int[] num = new int[] {1,2,3}
但:
int[] num;
num = {1,2,3}; error

最基本的方式:
int num[];
num = new int[3];
num[1] = 11
num[2] = 22
num[3] = 33;

二维数组的每行的列数可以不同;类似与c的指针数组
int [][] num;
num = new int[3][];
num[0] = new int[5];
num[1] = new int[3];
num[2] = new int[2];

int[][] num = {{1,2,3}, {4,5}, {6}}  // OK, 最大下标分别是2,1,0

for (int i=0; i <= 10; i++)  //在java中这个i只在for循环内部有效; 不像C语言
{
}

 

 

二. 面向对象基础

1.构造方法和类同名,必须定义,如果没有则系统自动产生一个不带参数的构造函数如: point();
.javap.exe --反编译工具;将字节码类反编译成源文件;
用缺省构造函数初始化,则成员变量被初始化为默认值:
数值型: 0
boolean: false
char     '\0'
对象:   null

2.重载 -- 构造函数的重载
  必要条件:参数类型和参数个数必须不同!

void output (int x, int y)
{
   x = x; //error;  this.x=x;
   y = y; //error;  this.y=y;
}   this在成员函数中指向当前对象;

无参构造函数可以调用带参数的构造函数:
Point()
{
this(1,1)   //已定义 Point(int a, int b)
}

3. 静态成员函数 -- 类方法-- 从类名可直接调用; Point.output(); not pt1.out();
static void output()
{
}
静态成员函数只能使用静态成员变量:
static int z;
静态方法和静态变量是属于某一个类,而不属于类的对象。
静态方法和静态变量的引用直接通过类名引用。 (也可用对象名)
在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之,则可以。
可以用类的对象obj去调用静态的方法method(),如:obj.method()
之所以main方法是static的;

虽然静态方法和非静态的成员函数在内存中都只有一个copy,但它们还是不同的;

4.常量
JAVA中没有define语句;所以常量可以用final声明:
final double PI = 3.1415926  (声明时必须赋初值)  -- 也可以将初始化放在构造函数中!
使用关键字final定义常量,例如:
    final double PI=3.1415926;
作为一种约定,在定义常量时,通常采用大写形式。
final常量可以在声明的同时赋初值,也可以在构造函数中赋初值。
为了节省内存,我们通常将常量声明为静态的(static)
static final double PI = 3.14;

5.继承 -- extends
父类,超类,基类
子类,派生类;
java不允许多继承;

6.覆盖
子类函数覆盖父类函数;
在子类中定义一个与父类同名、返回类型、参数类型均相同一个方法,称为方法的覆盖。
覆盖发生在子类与父类之间。

用super可以调用父类被覆盖的成员函数或者变量;
super.eat();

特殊变量super,提供了对父类的访问。
可以使用super访问父类被子类隐藏的变量或覆盖的方法。
每个子类构造方法的第一条语句,都是隐含地调用super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错.

子类自动调用父类构造函数,然后执行自身构造函数; 父类必须有无参的构造;不然自动执行会出错;

7.多态
通过覆盖父类的方法来实现,在运行时根据传递的对象引用,来调用相应的方法。
根据运行时传递参数的对象引用类型,来决定调用哪个方法;

8.instanceof用法
if(fh instanceof Animal)
  {
   System.out.println("fh is an animal's instance");
  }
  else
  {
   System.out.println("fh isn't animal's instance");
  }
输出: fh is animal's instance; 子类对象可以是父类的一个实例;

 

三(上).包,对象,方法,接口...

包,类,对象,方法,接口,垃圾回收,异常处理;

1.包 -- 包相当于类的限定名;

java.lang.String

package 名用小写;

>javac test.java

>java mybole/Test   //执行,并且必须创建mybole目录,将Test.class 放入目录;

package语句必须是文件中的第一条语句。也就是说,在package语句之前,除了空白和注释之外不能有任何语句。
如果不加package语句,则指定为缺省包或无名包。
包对应着文件系统的目录层次结构。
在package语句中,用“.”来指明包(目录)的层次。

在当前目录下生成包
    javac -d . Test.java
在指定目录下生成包
    javac -d E:\JavaLesson Test.java
-d 还能对应的生成目录结构,如:
>javac -d  . Test.java
则自动生成目录cn/mybole;

set classpath = %classpath%;D\cn\mybole;

1.1 import
引入包中的类。
    import java.io.File;
引入整个包。
    import java.io.*;
在同一包中的类可以互相引用,无需import语句。
java.lang 是默认就导入的,可以直接用;
如果没有导入一个类,也可以用:
java.io.File f;        //指定包路径进行外部类的使用
或者直接导入所有类: import java.io.*;

类的访问说明符
 (1)public   -- 跨包引用必须加上public关键字;
 (2)default(不加访问说明符时) -- 只能包内被访问
 -- 在不同的包之间访问类的时候,只能访问到声明为public的类;

类的其它修饰符
 (1)final  -- 表明它是最终的类;不能再派生出其它子类;
 (2)abstract  -- 抽象类

方法的访问说明符
 (1)public
 (2)protected
 (3)default(不加访问说明符时)
 (4)private
方法的其它修饰符
 (1)static
 (2)final
 (3)abstract
 (4)native
 (5)synchronized

访问说明符:     public   protected   default   private
同类               Y       Y         Y    Y    
同包               Y       Y         Y    N     
子类(不同包)     Y       Y         N    N    
通用性(不同包)   Y       N         N    N    

final:
为了确保某个函数的行为在继承过程中保持不变,并且不能被覆盖(overridden),可以使用final方法。
为了效率上的考虑,将方法声明为final,让编译器对此方法的调用进行优化。要注意的是:编译器会自行对final方法进行判断,并决定是否进行优化。通常在方法的体积很小,而我们确实不希望它被覆盖时,才将它声明为final。
class中所有的private和static方法自然就是final。
子类中不能覆盖父类的final方法;
子类中定义新的private和static方法,虽然编译不报错,但是只是产生了新的函数,并没有覆盖父类的函数;

抽象方法和抽象类:
在类中没有方法体的方法,就是抽象方法。
含有抽象方法的类,即为抽象类。 -- 如果类中声明了抽象方法,则类也必须声明为抽象的;
如果一个子类没有实现抽象基类中所有的抽象方法,则子类也成为一个抽象类。
我们可以将一个没有任何抽象方法的类声明为abstract,是为了避免由这个类产生任何的对象。
构造方法、静态方法、私有方法、final方法不能被声明为抽象的方法。
如果抽象类的子类没有实现父类的抽象方法,则它也是抽象的,必须加abstract;   可以用空实现 void fn(){}

JNI - JAVA Native Interface
tutorial...

Linux 平台 .SO文件为: 动态链接库

native方法:
native方法是用户在Java中可以使用,但不能编写的方法。
JNI(Java Native Interface),它允许Java虚拟机(JVM)内部运行的Java代码能够与用其它编程语言(如C、C++、汇编语言)编写的应用程序和库进行互操作。
JNI最大的好处是它没有对底层Java虚拟机的实现施加任何限制,因此,Java虚拟机厂商可以在不影响虚拟机其它部分的情况下添加对JNI的支持。程序员只需编写一种版本的本地(Native)应用程序和库,就能够与所有支持JNI的Java虚拟机协同工作
JNI可以理解为Java和本地应用程序之间的中介。

可以给类定义一个静态变量,在构造函数里让其自增来记录生成对象的数量;

垃圾回收:
垃圾回收器是一个低优先级的进程,在后台运行...当内存不足是才会调用;
System.gc(); 强制执行垃圾回收器

接口:
接口中所有的方法都是public abstract。
在接口中声明方法时,不能使用native、static 、final 、synchronized 、private 、protected等修饰符。
和public类一样,public接口也必须定义在与接口同名的文件中。
接口中可以有数据成员,这些成员默认都是public static final。
接口通常定义为public的
在类中实现接口的方法,必须也定义成public的;
实现类中必须实现接口中所有的方法,才能实例对象;否则它还是抽象类;
类中方法的形参可以用接口名;而实参调用的时候再使用实现类的对象来实例化;

接口的成员变量默认就是静态的公用常量!
访问方法有如下三种:
System.out.println(Math.PI);  //接口名称调用
  System.out.println(Arithmetic.PI); //实现类名调用
  System.out.println(a.PI);  //实现类对象调用

一个接口可以继承自另一个接口。
Java中不允许类的多继承,但允许接口的多继承。
interface Sofa extends Sittable, Lie
在Java中,一个类可以实现多个接口。
一个类在继承另外一个类的同时,可以实现多个接口。
class Sofa extends Chair implements Lie, HealthCare
{
 public void sleep(){};
 public void massage(){};
}
注意先后顺序!先继承再实现 --- extends放implements之前

 

三.(下)内部类,异常处理

1. 内部类
在一个类中定义另外一个类,这个类就叫做内部类或内置类 (inner class) 。
内部类可以让我们将逻辑上相关的一组类组织起来,并由外部类(outer class)来控制内部类的可见性。
当我们建立一个inner class时,其对象就拥有了与外部类对象之间的一种关系,这是通过一个特殊的this reference形成的,使得内部类对象可以随意的访问外部类中所有的成员。
内部类产生的字节码类名: outer$inner.class

new 产生的对象都在堆内存中!

Outer.this 来引用外部类成员变量; 外部类名.THIS
 
    class Inner
 {
  private int index=50;
  static void print()
  {
   int index=30;
   System.out.println(index);
   System.out.println(this.index);
   System.out.println(Outer.index);
   
  }
 }

静态的main方法不能直接new一个非静态的inner对象!
inner对象不能直接用new产生!

必须先产生一个外部类才能有内部类!
Outer.Inner inner = outer1.new Inner();// 必须与一个具体的外部类对象关联。

内部类也可以放在外部类的一个方法内定义,但是它的有效范围也只有方法内部!
内部类也可以放在一个条件语句中,或者语句块内;-- 无论它嵌套多深,它都能访问外部类的成员;

方法中声明的内部类如果要访问方法的局部变量,则该局部变量必须声明为final的常量!

当内部类声明为static后,生成时就无需先产生外部类的对象了,但也不能访问外部类对象的成员变量了; 只能访问静态的成员变量或者静态的成员方法了...

非静态的内部类不能有静态的方法;

在方法中定义的内部类,如果要访问方法中定义的本地变量或方法的参数,则变量必须被声明final。
内部类可以声明为private或protected;还可以声明为abstract或final。
内部类可以声明为static的,但此时就不能再使用外部类的非static的成员变量和非static的成员方法;
非static的内部类中的成员不能声明为static的,只有在顶层类或static的内部类中才可声明static成员。

我们为什么使用内部类
1、在内部类(inner class)中,可以随意的访问外部类的成员,这可以让我们更好地组织管理我们的代码,增强代码的可读性。
2、内部类可以用于创建适配器类,适配器类是用于实现接口的类。使用内部类来实现接口,可以更好地定位与接口关联的方法在代码中的位置。
3、内部类的更多用法。

匿名内置类:
/*Animal getAnimal()
 {
  return new Animal()
  {
   public void eat()
   {
    System.out.println("animal eat");
   }
   public void sleep()
   {
    System.out.println("animal sleep");
   }
  };            //在;前加入实现

其它用法: --- 接口中的方法和基类方法同名,但意义不同:
interface Machine
{
 void run();
}

class Person
{
 void run()
 {
  System.out.println("run");
 }
}

class Robot extends Person
{
 private class MachineHeart implements Machine     //用来实现接口中的run方法
 {
  public void run()
  {
   System.out.println("heart run");
  }
 }
 Machine getMachine()  //相当于也继承了Machine类
 {
  return new MachineHeart();
 }
}

class Test
{
 public static void main(String[] args)
 {
  Robot robot=new Robot();
  Machine m=robot.getMachine();  //返回一个实现类对象
  m.run();
  robot.run();
 }
}

JAVA中只能单继承,可以用接口和内部类的方法来解决C++中多继承实现的问题!

C类想继承A类和B类,可以继承A类然后定义一个getB()方法来返回一个匿名内部类对象(在这个getB()之后直接实现抽象类B;) 则运行时就可以用C类对象来实现A,B类对象作为形参的方法了。 例子如下:
class A
{
 void fn1()
 {
 }
}

abstract class B
{
 abstract void fn2();
}

class C extends A
{
 B getB()
 {
  return new B()
  {
   public void fn2()
   {
   }
  };
 }
}

class Test
{
 static void method1(A a)
 {
  a.fn1();
 }
 static void method2(B b)
 {
  b.fn2();
 }
 public static void main(String[] args)
 {
  C c=new C();
  method1(c);
  method2(c.getB());
 }
}

2. 异常处理

程序运行是遇到的错误;
通过异常类来实现的;
所有异常都有个基类:exception

异常类的层次结构:
 


打开一个不存在的文件、网络连接中断、数组下标越界、正在加载的类文件丢失等都会引发异常。
Java中的异常类定义了程序中遇到的轻微的错误条件。
   Java中的错误类定义了程序中不能恢复的严重错误条件。如内存溢出、类文件格式错误等。这一类错误由Java运行系统处理,不需要我们去处理。

Java程序在执行过程中如出现异常,会自动生成一个异常类对象,该异常对象将被提交给Java运行时系统,这个过程称为抛出(throw)异常。
当Java运行时系统接收到异常对象时,会寻找能处理这一异常的代码并把当前异常对象交给其处理,这一过程称为捕获(catch)异常。
如果Java运行时系统找不到可以捕获异常的方法,则运行时系统将终止,相应的Java程序也将退出。
try/catch/finally语句。

try
  {
   return excep.division(5,0);
  }
  catch(Exception e) //四种方法
  {
   System.out.println(“不能被0除”);    //用户定义异常信息
   System.out.println(e.getMessage() );  //直接返回该exception的错误信息
   System.out.println(e.toString());   //Returns a short description of this throwable.
   e.printStackTrace();  //打印Exception。实际上如果不处理,JVM会直接调用此函数(然后终止);
  }

catch 语句中一定要填入处理语句,如果留空{},则一旦发生异常,将无任何输出!

捕获异常可以在方法调用处,也可以在方法声明处!

如果方法声明处抛出异常,则报错在调用处! 如:public int fn1(int a,int b) throws Exception {}

如果在运行主函数后也加入 throws Exception, 则异常将交给JVM来处理,最省事的做法!!

最好还是自己处理异常,打印出详细错误或者进行正确处理!

catch语句可以写多个,如:
catch(ArithmeticException e) {....}
catch(Exception e) {....}    //但必须将具体异常写之前,通用的这个写后边!

runtimeException之外的异常都要求捕获,或者抛出;

声明中抛出异常用 throws
而抛出语句用 throw
catch(ArithmeticException e)
 {
  e.printStackTrace();
  throw e;
  //return 0;
 }

用户也可以自己定义额外的异常,如:除数小于零。
class DivisorIsMinusException extends Exception
{
 DivisorIsMinusException(String str)
 {
  super(str);
 }
}

finally:
try{}catch{}finally{} ----无论是否产生异常,finally语句都要执行,一般用来释放资源(网络,数据库连接等)。即便try或catch语句最后return了;
当程序终止运行后:System.exit(-1),finally就不执行了!


对于RuntimeException,通常不需要我们去捕获,这类异常由Java运行系统自动抛出并自动处理。
如果父类中的方法抛出多个异常,则子类中的覆盖方法要么抛出相同的异常,要么抛出异常的子类,但不能抛出新的异常(注:构造方法除外--构造方法不被覆盖)。
我们可以在方法声明时,声明一个不会抛出的异常,Java编译器就会强迫方法的使用者对异常进行处理。这种方式通常应用于abstract base class和interface中。

JAVA 编程规范:
package的命名
package 的名字由全部小写的字母组成,例如:cn.mybole。
class和interface的命名
class和interface的名字由大写字母开头而其他字母都小写的单词组成,例如:Person,RuntimeException。
class变量的命名
变量的名字用一个小写字母开头,后面的单词用大写字母开头,例如:index,currentImage。
class方法的命名
   方法的名字用一个小写字母开头,后面的单词用大写字母开头,例如:run(),getBalance()。
static final变量的命名
static final变量的名字所有字母都大写,并且能表示完整含义。例如:PI,PASSWORD。
参数的命名
参数的名字和变量的命名规范一致。
数组的命名
。   数组应该总是用这样的方式来命名:byte[] buffer。

 

 

 

 

 

 

 

 


 


TAG: java Java JAVA

小奇 引用 删除 yiran163   /   2009-03-30 18:35:27
3
小奇 引用 删除 yiran163   /   2009-03-30 18:35:03

LZ真用功,我最近也在学这个,就是他的视频,挺不错的
 

评分:0

我来说两句

日历

« 2024-03-21  
     12
3456789
10111213141516
17181920212223
24252627282930
31      

数据统计

  • 访问量: 6154
  • 日志数: 8
  • 建立时间: 2007-11-18
  • 更新时间: 2009-03-27

RSS订阅

Open Toolbar