课堂笔记学习java

bjxagu

浏览: 165355 次
性别:
来自: 长沙

最近访客更多访客>>

wsg_007

winmap

NEW张先生

luoyan3571

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

java 程序开发

Java C#C++C 企业应用

第一节课:

1. java 语言的诞生和特点(一般的教材都会有很详细的叙述,略)

2. java 学习的起步
(1)Sun公司要实现“编写一次，到处运行”（Write once，run anywhere）的目标，必须提供相应的Java运行平台，目前Java运行平台主要分为3个版本:J2SE(标准平台),J2EE(企业平台),J2ME(移动平台)

(2)学习Java必须从J2SE开始,当然得从了解在标准平台(J2SE)上是如何开发程序开始.

       a.首先从源文件(以.java结尾的文件)开始----经过java编译器(javac.exe)编译----生成字节码文件----根据内文件的本质再可以再产生两种文件:java应用   程序(application) 和 java小应用程序(applet);应用程序是由于java解释器(java.exe)执行,小应用程序是由浏览器执行(如IE)

       b.提到的编译器或解释器是哪来的呢?应该知道无论哪种语言的程序执行都有自身的运行环境,java语言是由SDK(software development kit也可叫jdk)平台支持,其提供了java虚拟机JVE(java virtual environment),包含运行环境和类加载器;还提供java编译器(javac.exe)和java解释器(java.exe)

       c.目前Sun公司已发布了SDK的1.5
        下载地址:http://www.javaresearch.org/members/jross/jdk/jdk-1_5_0-windows-i586.exe
        如果你使用的windows NT(2000,xp等)操作系统,安装完SDK后还应该正确配置系统的环境变量
        如果安装路径是c:\java\里,可如下配置,右键单击我的电脑->属性->高级->环境变量,然后选择系统变量里的"新建" 设置变量名为path 变量值为
        c:\java\jdk1.5\bin; 确定,再选择"新建"设置变量名为classpath 变量值为c:\java\jdk1.5\jre\lib\rt.jar;  确定则配置完毕(一个是配置JVM运行
        环境,一个是配置类路径)

    (3)java开发的过程和运行环境都明白了之后可以先简单的编写一个程序来运行
        a.应用程序:
        (a)打开记事本输入

程序代码:

public class Hello
                       {
                           public static void main (String args[ ])
                             {
                                  System.out.println("你好，很高兴学习Java");
                             }
                       }

保存为Hello.java(注意保存的名字必须是和主类的名字一样(包括大小写),所谓主类就是包含main方法的类)

        (b).按住"窗口+R"组合键打开运行窗口输入cmd进入dos界面转换盘符到刚刚java文件保存路径(例如保存在D盘,输入 D:  回车 )然有执行命令
         javac Hello.java 回车.这时会发现在和Hello.java同一个文件夹下生成了Hello.class 字节码文件,因为上面是一个应用程序的格式所以可以通过
          java解释器来生成应用程序.继续输入java Hello 回车.屏幕会显示"你好，很高兴学习Java"

        b.小应用程序
        (a)打开记事本输入

程序代码:

  import java.applet.*;
                        import java.awt.*;
                        public class Boy extends Applet  //entends代表Boy继承了小应用程序Applet类
                        {
                           public void paint(Graphics g)
                            {   g.setColor(Color.red);
                                g.drawString("我一边喝着咖啡，一边学Java呢",5,30);
                                g.setColor(Color.blue);
                                g.drawString("我学得很认真",10,50);
                            }
                         }

            保存为Boy.java
         (b)操作同理到生成Boy.class文件,应为程序的可是可以看出是属于小应用程序的,所以必须在浏览器中执行,众所周知浏览器只能加载网页文件(如html,xml,asp,php等 )所以要把boy.class下载网页文件中,新打开一个记事本,输入

程序代码:

<html>
<applet code=Boy.class width=100, height=100></applet>
</html>

保存为以.html结尾的文件(注意上述的.java或.class或.html文件都是在一个目录下),然后打开此网页文件即可预览

总结:第一节课主要简单的介绍了java的产生背景及其特点,并且从运行原理上引导大家来如何编写并运行java程序

第二节课

标识符关键字及数据类型

1.标识符: 用来表示类名,变量名,方法名,类型名,数组名,文件名的有效字符序列.
特点:java语言规定标识符由字母,下划线,美元符号和数字组成,并且第一个字符不能是数字字符.
java语言使用unicode标准字符集其包含65536个字符,比C和C++所使用的ASCII码多很多.

2.关键字:编程语言中已经被赋予特定意义的一些单词,不能把这类词作为名字来用,具体的关键字书上列举的很全,略.

3.数据类型

逻辑类型: boolean 用ture(真)和false(假)来赋值,没有赋值默认情况时表示false

整数类型:

(1) int型变量,内存分配4个字节的空间,即32位的空间,所以可以表示-2^31到2^31-1的整数,例如int x=10;

(2) byte型变量,内存分配1个字节的空间,范围从-2^7到2^7-1,例如byte x=127

(3) short型变量,内存分配2个字节的空间,范围从-2^15到2^15-1,例如short x=1000

(4) long型变量,内存分配8个字节的空间,范围从-2^63到2^63-1,例如long x=700000;

字符类型:

(1)常量:java使用unicode字符集,所以字符表中的每个字符都是一个字符常量,用单引号括上,例如'A','你','あ'
注意有些字符不能通过键盘直接输入到字符串中或程序中,这时就需要转意字符常量,例如:'\n'(换行),'\b'(退格),'\''(单引号)等等.

(2)变量:通过关键字char来定义字符变量
char型变量,内存分配2个字节的空间,因为是字符不存在负数的概念,所以范围从0到2^16-1(即65535),例如char name='刘',grade='A'

如果要查一个字符在unicode字符集里的顺序位置,必须使用int类型转换,如(int)'A',但不可以用short型转换(范围只有一半);同样道理如果想得到一个在0到65535之间的数字在unicode字符集中所对应的字符必须使用char型转换,如(char)30000.具体含义理解如下面代码

程序代码:

public class  Sign_Num
{   public static void main (String args[ ])
{ char chinaWord='你',japanWord='ぁ';
      int  p1=36328,p2=38358;
      System.out.println("汉字\'你\'在unicode表中的顺序位置:"+(int)chinaWord);
      System.out.println("日语\'ぁ\'在unicode表中的顺序位置:"+(int)japanWord);
      System.out.println("unicode表中第20328位置上的字符是:"+(char)p1);
      System.out.println("unicode表中第12358位置上的字符是:"+(char)p2);
    }
}

除了char以外还要稍微介绍一下String,在C或C++中,String是一个以空为终结的字符数组,而在java中它是java.lang包中的String类来创建一个字符串变量,因此字符串变量是一个对象.String的具体介绍在后面会学习到.

浮点类型:
(1)float型内存分配4个字节,占32位,范围从10^-38到10^38 和 -10^38到-10^-38
例float x=123.456f,y=2e20f; 注意float型定义的数据末尾必须有"f",为了和double区别

(2)double型内存分配8个字节,范围从10^-308到10^308 和 -10^-308到-10^-308
例double x=1234567.98,y=8980.09d; 末尾可以有"d"也可以不写

基本数据类型转换:

类型按精度从低到高:byte short int long float double
(1)当把级别低的变量赋值给级别高的变量时,系统自动完成数据类型的转换,例
    int x=100;
    float y;
    y=x;
   结果y的值应该是100.0
(2)当把级别高的变量赋值给级别低的变量时,必须使用显示类型转换运算,格式为:(类型名)要转换的值;例
    int x=(int)23.89f;
   结果x的值为23
   所以强制转换运算可能导致精度的损失
(3)当把一个整数赋值给一个byte,short,int或long型变量时,不可以超出这些变量的取值范围,否则必须进行类型转换运算,例
    byte a=(byte)128;
    byte b=(byte)-129;//超出范围
    结果a值为128,b值为127

用下面的代码来复习下:

程序代码:

public class Example2_2
{  public static void main (String args[ ])
{  int c=2200;
long d=8000;
      float f;
      double g=123456789.123456789;
      c=(int)d;
      f=(float)g;   //导致精度的损失
   System.out.print("c=  "+c);
System.out.println("  d=  "+d);
      System.out.println("f=  "+f);
System.out.println("g=  "+g);
    }
}

java中的数组

格式: 数组元素类型数组名字[ ] 或
数组元素类型 [ ]数组名字 例
float boy[];

创建数组: 数组名字=new 数组元素的类型[数组元素的个数]; 例
boy=new float[2]; //意思是boy获得了两个用来存放float型数据的空间

注意:和C和C++不同的是java允许使用int型变量来指定数组大小,例

int size=30;
double number=new double[size];

程序代码复习数组:

程序代码:

public class Example2_3
{ public static void main(String args[])
{   int a[]={100,200,300};
      int b[]={10,11,12,13,14,15,16};
      b=a;
      b[0]=123456;
      System.out.println("数组a:"+a[0]+","+a[1]+","+a[2]);
      System.out.println("数组b:"+b[0]+","+b[1]+","+b[2]);
      System.out.println("数组b的长度:"+b.length);
   }
}

总结:本节课把编程语言中的基础-关键字,数据类型等概念复习一遍,尤其是在java中的用法,为以后在使用变量的学习中做基础.

第三节课

运算符表达式和语句
因为大家肯定都学过C或C++的,所以这部分的内容自己可以回忆,都是一样的,略.

类和对象

1.类:类是组成java程序的基本要素.类封装了一类对象的状态和方法.类是用来定义对象的模板.
类的实现包括两个部分:类声明和类体.基本格式为:

程序代码:

class 类名
{
类体的内容
}

其中class是关键字,用来类定义."class 类名"是类的声明部分,类名必须是合法的java标识符,{}之间的内容是类

体,由变量的定义和方法(函数)的定义组成.
所谓变量定义,如int x或 intx=10;
但不能出现除声明以外的变量操作语句,如 int x; x=10;//是错误的

(1)变量:成员变量和局部变量
a.成员变量在整个类内都有效,局部变量只在定义它的方体体内有效.例:

程序代码:

class Sun
{ int distance;
  int find()
  {int a=12;
   distance=a;//合法,distance是成员变量在整个类内有效
   return distance;
  }
void g()
{inty;
y=a; //非法,a是局部变量,不在find()中就会失效
}
}

注意:成员变量在它在类中书写的先后位置无关.但不提倡把成员变量的定义分散的写在方法之间或类体的后面.

b.成员变量又分为实例成员变量(实例变量)和类成员变量(类变量)
类变量是指变量类型前加关键字 static 的成员变量,也称为静态变量.例:

程序代码:

class Sun
{float x; //实例变量
static int y; //类变量
}

c.当局部变量与成员变量名字相同时,则成员变量被隐藏,即这个成员变量在这个方法内暂时失效,例:

程序代码:

class Tom
{int x=90,y;
void f()
{int x=3;
y=x; //y得到的值应是3,因为成员变量x=90与y在此方法体里失效
}
}

但如果想在方法体内使用成员变量则通过关键字 this 来实现,例:

程序代码:

class 三角形
{float sideA,sideB,sideC,lengthSum;
void setside(float sideA,float sideB,float sideC)
{this.sideA=sideA; //this.sideA表示成员变量sideA
this.sideB=sideB;
this.sideC=sideC;
}
}

(2)方法
方法即是函数,包括声明和定义,在类体中是函数的定义,与C或C++中函数的声明或定义格式是一样的.

a.类方法和实例方法
实例方法即在方法返回值类型前加上关键字static,例:

程序代码:

class A
{int a;
float max(float a,float b)//实例方法
{//...}
static float min()//类方法
{//...}
}
[code]

b.方法的重载
方法的重载定义为多个函数定义时函数名必须相同,参数的类型和个数必须不同.例:

[code]
class Area
{float getArea(float r)
{return 3.14*r*r;}
double getArea(float x,int y)
{return x*y;}
float getArea(float x,float y)
{return x+y;}
double getArea(float x,float y,float z)
{return x*y*z*0.2;}
}

注意:在函数的重载中方法的返回值类型和参数的名字不参加比较.

c.构造方法
构在方法是一种特殊方法,它的名字必须与类名完全相同,而且没有类型,构造方法也可以重载的.
用法:一般用类创建对象时,使用构在方法,后面会有详细说明.

程序代码:

class 梯形
{float 上底,下底,高;
梯形()
{上底=60;
下底=100;
高=20}

梯形(float x,float y,float z)
{上底=x;
下底=y;
高=z;
}
}

2.对象
类是创建对象的模板.当使用一个类创建了一个对象时,也就是说给出了这个类的一个实例.
(1)对象的创建:包括对象的声明和为对象分配内存空间
声明格式: 类的名字对象的名字;

分配内存空间格式; 类的名字对象的名字=new 类的名字(); 例:

程序代码:

class XiyoujiRenwu
{   float height,weight;
    String head, ear,hand,foot, mouth;
    void speak(String s)
{  System.out.println(s);
    }
}
class A
{   public static void main(String args[])
{  XiyoujiRenwu  zhubajie;       //声明对象
       zhubajie=new  XiyoujiRenwu(); //为对象分配内存，使用new 运算符和默认的构造方法
    }
}

程序代码:

class Point
{  int x,y;
    Point(int a,int b)
{  x=a;
       y=b;
    }
}
public class A
{  public static void main(String args[])
{  Point p1,p2,p3;                 //声明对象p1和p2
      p1=new Point(10,10);         //为对象分配内存，使用 new 和类中的构造方法
      p2=new Point(23,35);  //为对象分配内存，使用 new 和类中的构造方法
      // p3=new Point(); 错误语句!当类中定义了一个或多个构造方法,那么java不提供默认的构造方法
}
}

(2)对象的内存模型
声明对象时,内存不分配空间,只存在一个空对象;当用new 分配内存空间时,类中的成员变量就会被分配到相应的空

间中,并通过构造方法(如果有)初始化,函数的入口地址也会被载入内存.但此时局部变量不会被分配内存空间,只有

当对象调用类中的函数时,函数中的局部变量才被分配空间,但函数执行完后,局部变量释放内存,所以如果在函数中

没有对局部变量进行初始化,就没有默认值,因此在使用局部变量之前,要事先为其赋值.
创建多个对象之间没有相互状态影响,个用个自的内存空间.

(3)对象的使用
对象不仅可以改变自己变量的状态,而且还拥有了使用创建它的那个类中的方法的能力,对象通过使用这些方法可以产生一定的行为.通过使用运算符" . "对象可以实现对自己的变量的访问和方法的调用.具体使用如程序例子:

程序代码:

class XiyoujiRenwu
{   float height,weight;
    String head, ear,hand,foot,mouth;
void speak(String s)
{  head="歪着头";
       System.out.println(s);
    }
}
class Example4_3
{    public static void main(String args[])
   {  XiyoujiRenwu  zhubajie,sunwukong;//声明对象
        zhubajie=new  XiyoujiRenwu();  //为对象分配内存
    sunwukong=new  XiyoujiRenwu();
        zhubajie.height=1.80f;         //对象给自己的变量赋值
        zhubajie.head="大头";
        zhubajie.ear="一双大耳朵";
        sunwukong.height=1.62f;        //对象给自己的变量赋值
        sunwukong.weight=1000f;
        sunwukong.head="绣发飘飘";
        System.out.println("zhubajie的身高："+zhubajie.height);
        System.out.println("zhubajie的头："+zhubajie.head);
        System.out.println("sunwukong的重量："+sunwukong.weight);
        System.out.println("sunwukong的头："+sunwukong.head);
        zhubajie.speak("俺老猪我想娶媳妇");          //对象调用方法
        System.out.println("zhubajie现在的头："+zhubajie.head);
        sunwukong.speak("老孙我重1000斤，我想骗八戒背我");   //对象调用方法
        System.out.println("sunwukong现在的头："+sunwukong.head);
   }
}

程序代码:

class 梯形
{   float 上底,下底,高,面积;
    梯形(float x,float y,float h)
{  上底=x;
       下底=y;
       高=h;
    }
    float 计算面积()
{  面积=(上底+下底)*高/2.0f;
       return 面积;
    }
    void 修改高(float height)
{  高=height;
    }
    float 获取高()
{  return 高;
    }
}
public class Example4_4
{  public static void main(String args[])
{  梯形 laderOne=new 梯形(12.0f,3.5f,50),laderTwo=new 梯形(2.67f,3.0f,10);
      System.out.println("laderOne的高是:"+laderOne.获取高());
      System.out.println("laderTwo的高是:"+laderTwo.获取高());
      System.out.println("laderOne的面积是:"+laderOne.计算面积());
      System.out.println("laderTwo的面积是:"+laderTwo.计算面积());
      laderOne.修改高(10);
      float h=laderOne.获取高();
      laderTwo.修改高(h*2);
      System.out.println("laderOne现在的高是:"+laderOne.获取高());
      System.out.println("laderTwo现在的高是:"+laderTwo.获取高());
      System.out.println("laderOne现在的面积是:"+laderOne.计算面积());
      System.out.println("laderTwo现在的面积是:"+laderTwo.计算面积());
    }
}

总结:介绍了类和对象及通过类体中的变量和方法来实现对对象的应用

第四节课

static的用法和包

上次课提到了static关键字,下面介绍一下具体的用法

1.实例变量和类变量

我们已经知道一个类可以使用new关键字可以创建多个不同的对象,这些对象被分配不同的内存空间.具体说的话,不同的对象的实例变量将被分配不同的内存空间,如果类中的成员变量有类变量,那么所有对象的这个类变量都分配分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量.如

程序代码:

class Takecare
{
static int x;
int y;
}

class A
{
Takecare A1=now Takecare();
Takecare A2=now Takecare();

//在此代码中如果给x赋值那么,A1.x 和A2.x指的是同一个内存空间,无论那个对象修改都是对一个x进行操作
}

当java程序执行时,类的字节码文件被加载到内存,如果该类没有创建对象,类的实例成员变量不会被分配内存.但是类中的类变量被加载到内存时,会被分配相应的内存空间.简单的说就是,没创建对象当类加载到内存时候,只有类变量(static)会被分配内存空间,只有创建对象时候实例变量才会被分配空间的.

像上面的例子里,在没有创建Takecare的对象时候,Takecare::x是有空间的即此时可以访问的,当且仅当Takecare A1=now Takecare()时A1.y才会有内存空间.

通过下面的例子体会一下,不同的对象会共享一个底

程序代码:

class 梯形
{   float 上底,高;
    static float 下底;
梯形(float x,float y,float h)
{   上底=x; 下底=y; 高=h;
    }
float 获取下底()
{   return 下底;
    }
void 修改下底(float b)
{   下底=b;
    }
}
class Example4_7
{   public static void main(String args[])
  {  梯形 laderOne=new 梯形(3.0f,10.0f,20),laderTwo=new 梯形(2.0f,3.0f,10);
       梯形.下底=200;                 //通过类名操作类变量
       System.out.println("laderOne的下底:"+laderOne.获取下底());
       System.out.println("laderTwo的下底:"+laderTwo.获取下底());
       laderTwo.修改下底(60);         //通过对象操作类变量
       System.out.println("laderOne的下底:"+laderOne.获取下底());
       System.out.println("laderTwo的下底:"+laderTwo.获取下底());
    }
}

2.实例方法和类方法

和实例变量和类变量的描述时是一样,当类的字节码加载到内存是类方法的入口地址就会被加载到相应的内存空间,即此时可以访问;而当且只有创建对象之后,实例方法的入口地址才会被加载到内存中,这是才可以调用.

既然知道了实例方法和类方法开始生效的时间,可以知道他们可以调用何种类的成员变量:

1)类方法因为是在创建对象之前就已经生效了,这时候实例变量还没有被分配内存空间,只有类变量被分配了内存空间,所以类方法只能调用被分配内存空间的变量即类变量;

2)实例方法是在创建对象之后才开始生效的,这是无论是类变量还是实例变量都已经被分配了内存空间,所以实例方法生效后可以调用类变量和实例变量.

程序代码:

class Fibi
{   public static long  fibinacii(int n)
{   long c=0;
        if(n==1||n==2)
           c=1;
        else
           c=fibinacii(n-1)+fibinacii(n-2);
         return c;
    }
}
public class Example4_8
{  public static void main(String args[])
{  System.out.println(Fibi.fibinacii(7));//  可见还没哟创建Fibi的对象时就可以调用fibinacii()方法,因为属于static修饰的类变量
   }
}

包

包是java中有效的管理类的一个机制,包有类似于目录结构的层次结构.通过import关键字可以在程序中使用包

语法格式:
import<包名>.*; //包含包中的所有类
import<包名><类名>//包含包中的指定类

例如:

import java.awt.*; //包含java.awt包中的所有类
import java.awt.JButton;//包含java.awt包中的JButton类

既然知道了怎么使用,那如何制作包呢,可以通过关键字package声明包语句.package语句作为java源文件的一个条语句,指明该源文件定义的类的所在包.

语法格式:
package 包名;

如果源文件中省略了package语句,那么源文件中定义命名的类将被隐含的认为是无名包的一部分,即源文件中定义命名的类在同一个包中,但该报没有名字而已.
包还可以是一个合法的表示符,也可以是若干个标识符加"."分割而成,如

package sunrise;
package sunrise.com.cn

程序如果使用了包的语句,如

package desney.tom;

那么目录必须包含有如下结构,如
C:\cartoon\desney\tom

并且要将源文件保存在目录C:\cartoon\desney\tom中,才能使用这个包,然后编译源文件:
C:\cartoon\desney\tom\javac 源文件.java
或
jacac C:\cartoon\desney\tom\源文件.java

从一个例子体会此过程:

程序代码:

package desney.tom;
public class PrimNumber
{   public void getPrimnumber(int n)
{  int sum=0,i,j;
       for(i=1;i<=n;i++)
{  for(j=2;j<=i/2;j++)
{  if(i%j==0)
                   break;
          }
          if(j>i/2)
            System.out.print(" "+i);
       }
     }
public static void main(String args[])
{  PrimNumber p=new PrimNumber();
       p.getPrimnumber(20);
    }
}

保存上述源文件到C:\cartoon\desney\tom下,然后编译

C:\cartoon\desney\tom\javac PrimNumber.java

运行程序时必须到desney\tom的上一层目录cartoon中来运行,如

C:\cartoon\java desney.tom.PrimNumber
因为起了报名,类PrimNumber的全名应该为desney.tom.PrimNumber

导入这个包时也要注意名称

程序代码:

import desney.tom.PrimNumber;

所以用package可以把认可类都打包然后在其他程序中使用,于c或c++中的头文件有着相似的效果,差别就是java中的包里只能是类

注意:使用import可以导入包中的类.在编写源文件时,除了自己编写的类外,经常需要使用java提供的去多类,这些类可能不在一个包中.在学习java时,使用已经存在的类,避免一切从头做起,这是面向对象编程的一个重要方面.

总结:具体的把static修饰的变量和方法的使用方法做了介绍;对java中包有了初步认识

分享到：

Java学习过程中应该理解的一些重点内容 | JDBC基础教程之语句

2008-08-05 23:43
浏览 928
评论(0)
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论