java 笔记

Java从入门到精通笔记

第0讲  开山篇

1.  Java se J2se        桌面

Java ee J2ee        网络

Java me J2me        手机

 

2.  SQL server   Mysql   Oracle

 

3． 学习软件编程的注意事项

    1.高效愉快学习

    2.先建立一个整体框架然后细节

    3.用什么再学习什么

    4.先知道how，再知道why

    5.软件编程是一门“做中学”学科，做了才会

    6.适当囫囵吞枣

    7.琢磨别人怎么做，不是我认为这么做

 

第1讲  内容介绍.项目演示.原理剖析

1.  课程包括：java面向对象编程，java图形界面，java数据库编程，java文件i/o流，java网络编程，java的多线程

 

2.  Java历史：1990 sun 启动 绿色计划

  1992 创建 oak语言—> java

  1994 gosling 参加 硅谷大会 演示java功能 震惊世界

  1995 sun 正式发布java第一个版本，目前最新的是jdk7.0

 

3.  java开发工具：记事本，jcreator，jbuilder，netbean，eclipse

 

4.  jdk包括：jre（java运行环境）

java的工具：编译器javac.exe解释执行器java.exe

java的类库：3600多个，常用的150多个

 

5.  第一个程序：

//功能：显示“HelloWorld”

 

//public:表示类是公共的，一个文件中只有一个public类

//class:表示这个是一个类

//HelloWorld:类名（公共类的类名，必须和文件名一样）

 

public class HelloWorld

{

//一个主函数，程序的入口

public static void main (String args[])

{

     //执行语句

     System.out.println("helloWorld!");

}

}

 

6.  Java源程序（.java文件）——>java字节码文件（.class文件）——>由解释执行器（java.exe） 将字节码文件加载到java虚拟机（jvm）——>字节码文件（.class）就会在java虚拟机中执行

 

第2讲    变量.数据类型

1.       在java里面int占4个字节，long占8个字节

 

2.       Java基本数据类型：

整数 ：(byte一个字节 ：-128---127  int四个字节：-2147483648---+2147483647   

short两个字节：-32768---+32767  long八个字节： )

小数（浮点）： float  double

布尔 ：boolean

字符：char（两个字节，可以存放汉字, char test1 ='中';）                引申到 字符串（类）

 

3.       在java中对char进行运算的时候，直接是当做ASCII码对应的整数

 

4.       数据不能从高精度到低精度的转换  Byte<short<int<long<float<double

float a=3.4；是过不去的，在java中小数默认是double（双精度）的

应该写成是float a=3.4f；

不过可以强制转换：int a=(int)1.2; int b=(int)1.9

5.       int a=1;int b=a+1.2;  a先是往高精度转换，然后赋给b，就报错  改成int a=1;double b=a+1.2; 或者     int a=1;float b=a+1.2f; 就解决了

 

第4讲    流程控制

1.       switch case语句中，switch条件表达式的数据类型应该和后面case的类型一致

 

2.       switch case语句中，可用的数据类型主要是：byte short int char enum

 

3.       当型循环：for 和 while 循环

 

4.       直到型循环： do while循环

 

第5讲    类与对象

1.       面向对象编程-类与对象

类名首字母大写    

类里面的元素叫类的成员变量/属性

2.       类的定义

package 包名；

class 类名 extends 父类 implements

接口名

{

           成员变量；

           构造方法；

           成员方法；

}

 

3.       如何创建对象：

先声明再创建 Cat  cat1；cat1=new  Cat();

         一步到位        Cat  cat1 =new  Cat();

 

4.       引用传递类似于指针一样

 

第6讲    成员属性  成员方法

1.       对象总是在内存中的

 

2.       类成员方法：方法就是指某些行为，表示为函数

public 返回数据类型  方法名 （参数列表）

{

           语句；//方法（函数）主题

}

 

3.       类名首字母大写  方法名首字母小写           驼峰法（匈牙利法）     下划线法

 

4.        指针是存储地址的，不因为它的指向的数据的类型而改变大小。

第7讲 成员方法（函数）  构造方法

1.       类的成员方法声明

访问修饰符 数据类型 函数名（参数列表）；

2.       方法的参数列表是多个的，参数列表的数据类型是任意的

3.       在调用某个成员方法的时候给出的具体数值的个数和类型要相匹配

4.       方法可以没有返回值

5.       先设计类，然后根据类创建对象

6.       构造方法（构造函数）：完成对新对象的初始化：

方法名和类名相同

没有返回值

在创建一个类的新对象时，系统会自动调用该类的构造方法完成对新对象的初始化

一个类可以定义多个不同的构造方法

每个类都有一个默认的构造方法

第8讲 this 类变量

1.       this属于类的对象的而不是属于类的

2.       5this不能在类的外部使用，只能在类定义时候使用！

3.       可以用类名直接访问静态变量

 

第9讲 类方法 封装

1.类变量是该类的所有对象共享的对象,一改全改了

2.定义语法：访问修饰符 static 数据类型 变量名

3.     public class Demo9

{

static int i=1;

 

static

{

           System.out.println("zhixingyicile");

           i++;

}//会自动执行一次，也只有一次

 

public Demo9()

{

           System.out.println("ffffffff");

           i++;

}

 

public static void main(String args[])

{

           Demo9 t1=new Demo9();

           System.out.println(Demo9.i);

           Demo9 t2=new Demo9();

           System.out.println(i);

 

}

}

 

4.类方法（静态方法、静态函数）：属于所有对象实例的

5.Java中:类变量（static）原则上用类方法（static）去访问；类方法中不能访问非静态变量

，就是非类变量，但是普通的成员方法可以访问静态变量（类变量）

使用：类名.类方法名     对象名.类方法名

6.非类变量就是实例变量，属于每个对象自己的

7.Java面向对象编程的三（四）大特征：封装、继承、多态（、抽象）

8.抽象：把一类事物的共有的属性和行为提取出来，形成一个物理模板，此研究问题的方法就是抽象

9.封装：把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作（成员方法），才能对数据进行操作。

10.封装的访问控制修饰符

11.四种访问控制符：

公开级别：public

受保护级别：对子类和同一个包中的类公开

默认级别： 没有修饰符，向同一个包的类公开，子类不可以访问类中默认级别的元素的

私有级别：用private修饰，只有类本身才能访问

公开>受保护>默认>私有

12.

13.包的三大作用：区分相同名字的类  当类很多的时候可以很好的管理类 控制访问范围

14.包的打包命令：package  com.xiaoming  一般放在文件的开始的地方

15.引包命令：improt 包名

 

第10讲 访问修饰符  重载  覆盖

1.一个文家中如果只有public类，那么这个public类可以不用主函数

2. 不想被继承就设为protected

3.子类最多只能继承一个父类，Java里面不允许一个子类继承多个父类，C++却可以，如Java中一定要呢，就用接口吧

4.Java的所有类都是Object 的子类，继承层次数没有限制

5.JDK6.0里面有202个包，3777个类、接口、异常、枚举、注释和错误

6.在做开发的时候多使用JDK帮助文档

7.方法重载：类的同一种功能的多种实现方式，取决于调用者传递的参数

8.方法重载注意事项：

  方法名相同

  方法的参数类型，个数，顺序至少有一项不同

  方法的修饰符可以不同

  方法的返回类型可以不同

另外：

  只是返回类型不一样并不构成重载

  只是控制访问修饰符不一样不构成重载

 

第11讲  约瑟夫问题（丢手帕问题）

1.方法覆盖的：子类有一个方法和父类的某个方法名称、返回类型、参数一样

2.方法覆盖注意：

  子类的方法的返回类型、参数、方法名称要和父类的一样，否则编译出错

  子类方法不能缩小父类方法的访问权限，但是扩大是可以的

3.丢手帕问题：

 

第十二讲  多态

1.多态性:访问子类可以通过访问父类：

Animal cat =new Cat();

Animal dog =new Dog();

2.在使用多态的时候，如果有使用覆盖函数，那么被覆盖的方法（即是父类中的的那个相应的方法）是要存在的。

3. 多态：一个引用（类型）在不同情况下的多种状态，可使代码更加灵活

4.java允许父类的引用变量引用它子类的实例，是自动完成的

 

代码：

 

package com.agui;

public class Demo5 {

 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Dog2 ddd=new Dog2();
  ddd.cry();
  Cat2 ccc=new Cat2();
  ccc.cry();
  Animal2 an =new Cat2();
  an.cry();
  Master xxx=new Master();
  xxx.feed(new Dog2(),new Bone());
 }

}

//动物类
 class Animal2
{ 
 String name;
 int age;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }

 //叫
 public void cry()
 {
  System.out.println("buxiaodezenmejiao");

 }
 public void eat()
 {
 
  System.out.println("buzhidao chishenme");
  
 }
}
 
 class Master
 {
  //使用多态，方法就可以用一个了
  
 public void feed(Animal2 an,Food f)
  {
   an.eat();
   f.showName();
  }
 }

 
class Food
{
 String name;
 public void showName()
 {
 
 }
}

class Fish extends Food
{
 public void showName()
 {
  System.out.println("yurou");
  
 }
 
}
class Bone extends Food
{
 public void showName()
 {
  System.out.println("gutou");
  
 }
 
}

 

class Cat2 extends Animal2
{
//猫自己叫 
 public void cry()
 {
  System.out.println("maomaojiao");
 }
 public void eat()
 {
  System.out.println("aichiyu");
 }

}

class Dog2 extends Animal2
{
 //gou自己叫 
 public void cry()
 {
  System.out.println("wangwangjiao");
 }
 public void eat()
 {
 
  System.out.println("aichigutou");
  
 }

}

 

第十三讲  抽象类接口 （难点重点）

1.父类方法的不确定性，用抽象类修饰这个方法，abstract。

2.抽象类还是可以一样被继承

3. 当一个类继承的类是抽象的类时候，就要把抽象类中的所有的抽象方法全部方法实现

4.用abstract关键词来修饰的时候，一定是抽象类和抽象方法

5.在使用中不多，公司笔试的时候考很多

6.抽象类不能被实例化，只有被继承以后再去实例化

7.抽象类不一定要包含abstract方法，就算没有abstract方法，也不能实例化它

8.一旦类包含了abstract方法，这个类必须声明为abstract

9.抽象方法不能有主体“{}“

 

 

package com.s1;

 

public class Demo1 {

 

  

    public static void main(String[] args) {

       // TODO Auto-generated method stub

 

    }

 

}

 

abstract class Animal

{

    String name;

    int age;

    abstract public void cry();

  

}

 

//当一个类继承的类是抽象的类时候，就要把抽象类中的所有的抽象方法全部方法实现

class Cat extends Animal

{

    public void cry()

    {

       //do nothing

       System.out.println("喵喵叫");

     

    }

}

 

 

10.接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来，语法：

class 类名 implements 接口

{

         方法；

         变量；

}

 

 

 

package com.s1;

 

public class Demo2 {

    public static void main(String[] args)

    {

       Computer computer=new Computer();

       Camera camera=new Camera();

       Phone phone=new Phone();

       computer.useUsb(camera);

       computer.useUsb(phone);

    }

 

}

 

interface  Usb

{

    //声明了两个方法

    //开始工作

    public void start();

    //停止工作

    public void stop();

  

}

 

//照相机,实现Usb接口

//一个类实现接口就要把所有的类全部实现！

class Camera implements Usb

{

    public void start()

    {

       System.out.println("我是照相机，我开始工作了！");

    }

    public void stop()

    {

       System.out.println("我是照相机，我停止工作了！");

     

    }

     

}

 

//手机类

 

class Phone implements Usb

{

    public void start()

    {

       System.out.println("我是手机，我开始工作了！"); 

    }

    public void stop()

    {

       System.out.println("我是手机，我停止工作了！"); 

     

    }

  

}

 

//计算机

class Computer

{ 

    //开始使用USB接口

    public void useUsb(Usb usb)//体现多态

    {

       usb.start();

       usb.stop();

  

    }

}

11.接口不能被实例化

12.接口中的所有方法都不能有主体

13.抽象类里面是可以有实现了的方法的

14.接口中的所有方法都不能有主体，即都不能被实现

15.接口是更加抽象的抽象类！！！！

16.一个类继承抽象类或是使用接口，那么就要实现所有的抽象方法

17.一个类可以实现多个接口

18.接口中可以有变量（但是不能用private，protected修饰）

19.接口中的变量本质上都是静态的，而且是final，不管你加不加static，所以可以直接使用：接口名.变量名

20.在 java开发中，经常把常用的变量定义在接口中作为全局变量使用

  访问形式：接口名.变量名

21.一个接口不能继承其它的类，但是可以继承别的接口

22.接口体现了程序设计的多态和高内聚低耦合的思想

 

第十四课 final 作业评讲

1.实现接口和继承父类的区别：

2.java是单继承，一个类只允许继承一个父类，这种单继承的机制可以保证类的纯洁性，比C++的多继承机制简洁

3.实现接口可以看做是对单继承的一种补充

4.继承是层次式的，不太灵活，修改某个类就会打破这种继承的平衡，但是接口就不会，因为只针对实现接口的类才起作用

5.用接口体现多态：

6.前期绑定：在程序运行之前就进行绑定，由编译器和连接程序实现，又叫静态绑定，如static方法和final方法，包括private方法，它是隐式fi nal的

7.后期绑定：在运行的时候根据对象的类型进行绑定，由方法调用机制实现，因此又叫动态绑定，或是运行时绑定，除前期绑定外的所有方法都属于后期绑定

8.

//展示接口实现多态的概念

 

package com.s2;

 

//汽车接口

interface Car

{

    String getName();//获得名字

    int getPrice();//获得价格

}

 

//宝马

 class BMW implements Car

 {

     public String getName()

     {

        return "我日，宝马啊";          

     }

     public int getPrice()

     {

        return 800000;

     }

    

 }

 

class QQ implements Car

{

    public String getName()

    {

       return "没意思的，qq";

    }

  

    public int getPrice()

    {

       return 20000;

    }

 

}

 

 

public class CarShop

{

    //售车的收入

    private int money=0;

  

 

    //卖出一部车

    public void sellCar(Car car)

    {

       System.out.println("车型："+car.getName()+"价格是："+car.getPrice());

       money+=car.getPrice();

    }

  

    public int getMoney()

    {

       return money;   

    }

  

    public static void main(String []args)

    {

       CarShop a=new CarShop();

       //卖出宝马

       a.sellCar(new BMW());

       //卖出qq

       a.sellCar(new QQ());

     

       System.out.println("总收入是："+a.getMoney());

     

    }

  

}

9.final概念：final可以修饰变量和方法

当不希望父类的某些方法被子类覆盖的时，可以用final修饰

当不希望类的某个变量的值被修改，可以用final修饰

当不希望类被继承时，可以用final修饰

10.final修饰的变量一般用下划线书写

11.如果一个变量是final的，那么定义时候必须赋初值

12.final修饰的变量又叫常量，一般用XX_XX_XX命名

13.final什么时候用：

  处于安全的考虑，类的某个方法不允许修改

  类不会被其它的类继承

  某些变量值是固定不变的，比如pi

第15讲  讲题目

1.switch只能对int、short、byte以及枚举类型进行判断，case后面只能是常量表达是

2.猜拳的java程序设计：

         有个人Tom设计他的成员变量，成员方法，和电脑猜拳，电脑每次都产生一个随机数0，1，2，0表示石头，1表示剪刀，2表示布。请实现：

第16讲 数组

1.数组是可以存放多个同一类型的数据

2.用法：

  程序员用法：数组定义：数据类型 数组名[]=new 数据类型[大小];

                                                      如：int  arr[]=new int[5];

或者是int[]  arr=new int[5];

                                                      或者是int  []arr=new int[5];

              数组引用：数组名[下标]

  没事找事用法：数组定义： int  arr[];  arr=new int[5];

或者是int[]  arr;  arr=new int[5];

或者是int  []arr; arr=new int[5];

数组引用：数组名[下标]

  古板用法：int a[]={1,2,3,4,5,6,7,8,9,0};

数组引用：数组名[下标]

 

3.知道数组的大小：arr.length(成员属性)

4.引用在栈里面，对象在堆里面

5.对象数组：

 

 

package com.test1;

import java.io.*;

public class Demno5_2 {

 

    public static void main(String[] args)throws IOException{

  

       Dog dog[]=new Dog[4];

     

       InputStreamReader isr=new InputStreamReader(System.in);

       BufferedReader br=new BufferedReader(isr);

       for (int i=0;i<4;i++)

       {

           dog[i]=new Dog();

           System.out.println("请输入第"+(i+1)+"只狗名字");

           //输入狗名

           //try {

              String name=br.readLine();//将名字赋给对象

           //} catch (Exception e) {

              // TODO Auto-generated catch block

           //  e.printStackTrace();

           //}

         

           dog[i].setName(name);

           System.out.println("请输入第"+(i+1)+"只狗的体重：");

           String s_weight=br.readLine();

           float weight=Float.parseFloat(s_weight);

           // 将名字赋给对象

           dog[i].setWeight(weight);

       }

       float allWeight=0;

       for(int i=0;i<4;i++)

       {

           allWeight+=dog[i].getWeight();

       }

       float avgWeight=allWeight/dog.length;

       System.out.println("狗总体重:"+allWeight+"狗平均体重："+avgWeight);

    }

 

}

  

//定义一个狗类

class  Dog

{

    private String name;

    private float weight;

 

    public void setName(String name)

    {

       this.name = name;

    }

    public void setWeight(float weight)

    {

       this.weight = weight;

    }

    public float getWeight()

    {

       return this.weight;

    }

}

 

 

4.对象、字符串的很多不能用”==”,用的话是表示地址相等，比较字符串的内容是否相等是用equals方法

5.      数组可存放同一类型数据

         简单数据类型（int,float）数组，可以直接赋值

         对象数组在定义后，赋值时候需要再次为每个对象分配空间【即是：new 对象】

         数组大小必须事先指定，如：int x;int a[]=new int[x];是可以的

         数组名可以理解为指向数组首地址的引用

         数组的下标是从0开始标号的

 

6.排序的介绍：排序是将一群数据依据一定的顺序进行排列的过程

         分类：

内部排序：将要排序的所有数据都加在到内存里面进行排序，包括交换式排序法、选择式排序法和插入式排序法

外部排序：数据量过大，无法全部加载到内存，包括合并排序法和直接合并排序法

 

7.交换式排序法属于内部排序法，是运用数据值比较后，依判断规则对数据的位置进行交换，已达到排序的目的，它包括：冒泡排序法（Bubble sort）和快速排序法(Quick sort)

 

8.冒泡排序法：

第一次写法：

package com.test1;

 

public class Demo5_3 {

    public static void main(String[] args)

    {

       int arr[]={1,6,0,-1,9,4,5,1,-5,4,7};

       //排序开始

       //

       for(int i=0;i<arr.length-1;i++)

       {

           //内层循环开始逐一比较，如果发现前一个数比后一个数大，就交换

           for (int j=0;j<arr.length-i-1;j++)

           {

            

              if(arr[j]>arr[j+1])

              {

                  arr[j]=arr[j]^arr[j+1];

                  arr[j+1]=arr[j]^arr[j+1];

                  arr[j]=arr[j]^arr[j+1];       

              }

            

           }

         

       }    

       for(int i=0;i<=arr.length-1;i++)

       {

           System.out.print(arr[i]+" ");

       }    

           System.out.print("总长度是"+arr.length);

    }

 

}

 

我们进行改进，进行封装试试看：

package com.test1;

 

public class Demo5_3 {

    public static void main(String[] args)

    { 

     

       int arr[]={1,6,0,-1,9,4,5,1,-5,4,7};

     

       Bubble bubble=new Bubble();

       bubble.set(arr);

     

  

       //排序开始

       //

    }

 

}

 

class Bubble

{

    public void set(int arr[])

    {

       for(int i=0;i<arr.length-1;i++)

       {

           //内层循环开始逐一比较，如果发现前一个数比后一个数大，就交换

           for (int j=0;j<arr.length-i-1;j++)

           {

            

              if(arr[j]>arr[j+1])

              {

                  arr[j]=arr[j]^arr[j+1];

                  arr[j+1]=arr[j]^arr[j+1];

                  arr[j]=arr[j]^arr[j+1];       

              }

            

           }

          

       }    

       for(int i=0;i<=arr.length-1;i++)

       {

           System.out.print(arr[i]+" ");

       }    

           System.out.print("总长度是"+arr.length);  

    }

}

9.注意：新建一个类的对象而且调用了类的方法时候，虚拟机会在主栈的外面给调用的这个方法分配一个相应的栈，在外面的这个栈里面对数组或者对象的操作就是对主栈的相应的数组或者对象的操作，但是不是针对所有的类型，如果是int等简单类型就不行。

10.选择式排序法：选择排序法（快于冒泡排序法）：

         选择排序法（select sorting）也是一种简单的排序方法，第一次从R[0]~R[n-1]中寻选取最小值，与R[0]交换，第二次从R[1]~R[n-1]中选取最小值，与R[1]交换，第三次从R[2]~R[n-1]中选取最小值与R[2]交换……总共（n-1）次。

第十八讲  排序 查找

1.插入式排序法分为：

         插入排序法（Insertion Sort）

         谢尔排序法（shell sort）

         二叉树排序法（Binary-tree sort）

2.插入式排序法—插入排序法（Insertion Sorting）

基本思想：把n个待排序的元素看成是一个有序表和一个无序表，开始时候有序表只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出一个元素，把她的排序吗一次和有序表元素的排序码进行比较，将它插入到有序表的适当位置，使之成为新的有序表。

3.插入法的实现：

package com.test1;

//import java.util.*;

 

public class Demo5_4 {

    public static void main(String[] args)

    { 

       int arr[]={1,6,3,10,8,7,9,0,0,-199,9};

       Insert insert =new Insert();

       insert.sort(arr);

    }

}

 

 

class Insert

{

    public void sort(int arr[])

    {

       for (int i=1;i<arr.length;i++)

       {

         

           int insertVal=arr[i];

           //insertVal准备和前一个数比较

           int index=i-1;

           while(index>=0&&insertVal<arr[index])

           {

              //将要把arr[index]向后移动

              arr[index+1]=arr[index];

              //让index向前移动

              index--;           

           }

           //将indexVal插入到适当位置

           arr[index+1]=insertVal;

       }

     

       System.out.println("结果是:");

       for (int p=0;p<=arr.length-1;p++)

       {

           System.out.print(arr[p]+" ");    

       }

    }

 

}

4.交换式排序法——快速排序法

快速排序（Quick sort）是对冒泡排序法的改进，1962年提出的，使用递归思想。

5.希尔排序法

6.合并排序法：外部排序法最常用的方法，如果数据量太大无法一次完全加载，可使用外部辅助内存来处理数据，主要应用在文件排序。

7.查找：顺序查找和二分查找（使用二分查找前提是先排好序）

 

package com.test1;

public class Demo5_5
{
 public static void main(String[] args)
 {
  int arr[]={2,5,7,12,15};
  BinaryFind bf=new BinaryFind();
    bf.find(0, arr.length-1, 3, arr);
    bf.find(0, arr.length-1, 12, arr);
 }
}

class BinaryFind
{
 public void find (int leftIndex,int rightIndex,int val,int arr[])
 {
  //首先找到中间的数
  int midIndex=(rightIndex+leftIndex)/2;
  int midVal=arr[midIndex];
  
  if (rightIndex>=leftIndex)
  {
   //如果要找的数比midVal小
   if(midVal>val)
   {
    find(leftIndex,midIndex-1,val,arr);

   }else if(midVal<val)
   {
    //在右边找
    find(midIndex+1,rightIndex,val,arr);   
   }
   else if(midVal==val)
   {
   
    System.out.println("找到了，它的下标是："+" "+midIndex);
   }
  
  }
  else     
  {
   System.out.println("我日，真的找不到啊，麻烦你核对一下再找好不好！");
  }

 }

}

第十九讲 多维数组

1.多维数组，定义：

    语法：类型 数组名[][]=new 类型[大小][大小] int a[][]=new int [2][3]

2.

 

public class Demo5_6

{

 

    public static void main(String[] args)

    {

       int a[][]=new int[4][6];

       a[1][2]=1;

       a[2][1]=2;

       a[2][3]=3;

     

       for (int i=0;i<4;i++)

       {

           //列

           for (int j=0;j<3;j++)

              System.out.print(a[i][j]+" ");

              System.out.println();         

       }

     

    }

}

第二十讲 二进制 位运算 移位计算

1.0的反码和补码都是0

2.我们只会针对有符号的数才讲反码补码

3.java没有无符号数，换言之，java中的数都是有符号的

4.在计算机运算的时候，都是以补码的方式运算的

5.按位 与& 或| 异或^ 取反~

6.~-2=-3(00000010->11111101->11111100->10000011)

7.2&3=00000010  2|3=00000011  ~-5=（1000 0101->11111010->11111011(补码)->00000100）4

8.有3个移位运算符：

>>算术右移：低位溢出，符号位不变，并用符号位补由于移动而空出的高位

<<算术左移：符号位不变，地位补0

>>>逻辑右移：

9.记住：对负数操作就要先找补码！！！正数也是，只不过不边罢了。得到的结果如果是正数就结束，如果是负数就再折腾一下，转变成原码才行。

10.-1移动任意位都是-1

11.1<<2(相当于是*4)=4，-1<<2(相当于是*4)=-4

12. 而对于有符号数，其左移操作还是逻辑左移，但右移操作是采用逻辑右移还是算术右移就取决于机器了！（算术右移和逻辑右移的区别是：算术右移不右移符号位，即最高位，右移后前补0还是1取决于符号位的值;逻辑右移执行时将移动符号位，右移后前补0）

 

第21讲  集合

1.集合类 泛型 异常的处理

2.解决方法：链表或者集合类（可以动态的改变），请熟悉常用的集合类

3.集合类分类：

    List结构的集合类：

        ArrayList类，LinkedList类，Vector类，Stack类

    Map结构的集合类

        HashMap类，HashTable类

    Set结构的集合类

        HashSet类，TreeSet类

    Queue结构的集合类

        Queue接口

4.Java中所有的对象都是从Object继承下来的

5.子类交给父类，可以自动转换，反过来就要强制转换

6.ArrayList中可以多次存放同样的人，ArrayList本质是存放引用

7.从ArryList中删除对象

 

package com.test1_1;

import java.util.*;

public class Demo5

{

 

    public static void main(String[] args)

    {

       ArrayList a1=new ArrayList();

       System.out.println("a1大小："+a1.size());

       //向al中加入数据（类型Object）

       //创建一个职员

       Clerk clerk1=new Clerk("老大",50,1000);

       Clerk clerk2=new Clerk("老二",45,1000);

       Clerk clerk3=new Clerk("老三",35,1000);

 

       //将clerk1加入a1中

       a1.add(clerk1);

       a1.add(clerk2);

       a1.add(clerk3);

       //可不可以放入同样的人？

       System.out.println("a1大小："+a1.size());

     

       //如何访问a1中的对象（数据）

       //访问第一个对象

     

     

       //Clerk temp=(Clerk)a1.get(2);//a1.get(0)返回object类型，要强制转换

     

       //System.out.println("第一个人是："+temp.getName());

     

       //遍历所有的对象

     

       for (int i=0;i<a1.size();i++)

       {

           Clerk temp=(Clerk)a1.get(i);

           System.out.println("第"+(i+1)+"个人是："+temp.getName());

       }

       //如何在a1中删除一个对象

       a1.remove(1);

       System.out.println("第2个人被删除了，现在呢？看看下面的：");

     

       for (int i=0;i<a1.size();i++)

       {

           Clerk temp=(Clerk)a1.get(i);

           System.out.println("第"+(i+1)+"个人是："+temp.getName());

       }

     

    }

}

 

class Clerk

{

 

    public String getName()

    {

       return name;

    }

    public float getSal()

    {

       return sal;

    }

    public int getAge()

    {

       return age;

    }

  

    String name;

    private float sal;

    int age;

  

    public Clerk(String name,int age,float sal)

    {

       this.name=name;

       this.sal=sal;

       this.age=age;

    }

  

  

}

第22讲  集合

1.字符串相等是地址相等而不是内容相等！

2.雇员管理系统程序的编写（自己改进了一点，不完全，继续改进……）

3.LinkedList

    addFirst表示把元素加在链表的最前面（类似于栈一样）

    addLast表示把元素加在链表的最后面（类似于队列一样）

getFirst

getLast

remove

removeFirst

removeLast

 

 

 

 

 

 

4.Vector:

  

 

 

5.Stack用法：（加的时候是在前加的）

第二十三讲  集合

1.HashMap

    HashMap hm=new HashMap();

    Emp emp=new Emp(“s001”,”aaa”,3.4f);

2. HashMap可以存放空置但是HashTable不能存放空值。

3.Hashtable是基于陈旧的Dictionary的，HashMap是Java1.2引进的Map接口的一个实现

4.Hashtable是线程同步的，这个类中的一些方法保证了Hashtable中的对象是线程安全的。而HashMap是异步的，因而HapMap中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用HashMap是一个很好的选择，这样可以避免由于同步而带来的不必要的性能开销，从而提高效率。

5.值：HashMap可以让你将空值作为一个表的条目的key或value，但是Hashtable是不能放入空值的（null）

6.HashTable由于是同步的，有锁，因此是存在等待的，HashMap允许

7.ArrayList和Vector区别：

    Vector是同步的，是线程安全的，更安全

    ArrayList是异步的，不是线程安全的，没有Vector安全

    数据增长：Vector缺省情况下是自动增长原来一倍的数组长度，适合保存大量的数据；ArrayList是原来的50%

8.如果要求线程安全，使用Vector、Hashtable，否则ArrayList、LinkedList、HashMap

9.如果要求键值对，使用HashMap、Hashtable

10.如果数据量大又考虑线程安全，使用Vector

第二十四讲  集合补充

HashMap和Hashtable都是实现Map的接口的，ArrayList和LinkedList都是实现List的接口的

 

第二十五讲 泛型 异常

1.泛型是Java1.5 的新特性，泛型的本质是参数化类型，也就是说所操作的类型被指定为一个参数，这种参数可以在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法

2.Java引入泛型的好处就是安全简单，可以在开始的时候就约束集合的类型

3.泛型的好处就是在编译的时候检查类型的安全，并且所有的强制转换都是自动和隐式的，提高代码重用率

 

package com.test1_1;

import java.util.*;

 

public class Demo7_4 {

 

  

    public static void main(String[] args) {

       // TODO Auto-generated method stub

       ArrayList<Dog> al=new ArrayList<Dog>();

       Dog dog1=new Dog();

       al.add(dog1);

       //Dog temp=(Dog)al.get(0);

       //Cat temp1=(Cat)al.get(0);

       Dog temp=al.get(0);//这个时候就不需要强制类型转换

  

    }

 

}

 

 

4.Java的反射机制:拿到一个类的很多信息！好处是：编写一些灵活性更好的代码

 

 

package com.test1_1;

import java.lang.reflect.Method;;

 

public class Demo7_5

{

 

    public static void main(String[] args)

    {

        //Gen<Integer> gen1=new Gen<Integer>(2);//我们这个时候调用了构造函数，注意新建的时候都是调用了构造函数

        //gen1.showTypeName();

          

        Gen<Bird> gen2=new Gen<Bird>(new Bird());

        gen2.showTypeName();

      

    }

 

}

 

//定义一个鸟类Bird

class Bird

{

    public void test1()

    {

        System.out.print(" 鸟鸟");

    } 

    public void count(int a,int b)

    {

        System.out.println("两个数的和是："+(a+b));    

    } 

}

 

//定义一个类

class Gen<T>

{

    private T o;

    //构造函数

    public Gen(T a)//构造函数

    {

        o=a;      

    }

  

    //得到T的类型的名称

  

    public void showTypeName()

    {

        System.out.println("类型是："+o.getClass().getName());

      

        // 通过反射机制，我们可以得到T这个类型的很多信息，比如得到成员函数名

      

        Method []m=o.getClass().getDeclaredMethods();//函数的一些信息

        //打印

        for (int i=0;i<m.length;i++)

        {

            System.out.println(m[i].getName());       

        }

  

    }

  

}

5.使用泛型的优点（GJ表示泛型Java）：类型安全

                 向后兼容

                 层次清晰

                 性能较高

6.异常处理：当出现程序无法控制的外部环境问题的时候（用户提供的文件不存在，文件内容损坏，网络不可用……），JAVA就会用异常对象来描述

7.JAVA中用2种方法处理异常

    1.在发生异常的地方直接处理

    2.将异常抛给调用者，让调用者自己处理

8.异常分类：

    检查性异常：java.lang.Exception(编译时候检查出的)，外在条件不满足引发的，不是程序的错，很可能是远程机器名出错，如果不处理程序就不能被编译。

    运行期异常：java.lang.RuntimeException，意味着程序存在Bug，如数组越界，0被除，入参不满足规范……需要更改程序来处理

    错误：java.lang.Error，一般很少，很难通过程序解决，可能源于程序的Bug，但是一般更可能源于环境问题，如内存耗尽，错误在程序中无需处理，而由运行环境处理。

顶层都是Throwable

9.检查异常举例：

10.tracert（trace route）查看路由信息

11.route print：路由表信息打印出来

12.netstat –an：谁连接到你的电脑上的

 

第二十六讲 异常和异常的处理

1.异常处理：

    Try…catch：程序运行产生异常时候，将从异常发生点中断程序并向外抛出异常信息

2.设置了捕获，而且真的捕获到了异常，后面的异常就检测不到，遵循一个先后的顺序，但是程序还是会继续执行，正常程序和e.printStackTrace();执行后显示的顺序貌似有点乱了，所以书上推荐用System.out.println("message:="+e.getMessage());显示顺序不会乱

3. 在出现异常的地方就中止执行代码，然后直接进入到catch语句，如果有多个catch语句，就进入匹配异常的那个catch语句

4.      try

       {

           FileReader fr=new FileReader("d:\\12334.txt");

       }

       catch (Exception e) //或者Exception e，Exception e是捕获所有的

       {

           System.out.println("message:="+e.getMessage());

           e.printStackTrace();

       }

5.finally:如果把finally块置try…catch语句后，finally块一般都会得到执行，相当于一个万能的保险，即使前面的try块发生异常，而又没有对应异常的catch块，finally块将马上执行

6.文件被打开一直没有关闭是很恐怖的！所以就有了finally语句，不管有没有异常都会执行，一般说，把需要关闭的资源[文件，连接，内存……]

7.以下情况finally将不被执行：

    Finally块中发生了异常

    程序所在的线程死亡了

    使用了System.exit(-1)

    关闭CPU

8.

package com.test1_1;

import java.io.*;

import java.net.*;

 

public class Demo7_6

{

 

    public static void main(String[] args)

    {

       //检查异常1.打开文件

       FileReader fr=null;

       try

       {

           //在出现异常的地方就中止执行代码，然后直接进入到catch语句

           //如果有多个catch语句，就进入匹配异常的那个catch语句

           fr=new FileReader("d:\\1234.txt");//如果找不到咋办啊？你必须处理

           //Socket s=new Socket("192.1638.0.1",8080);

 

       }

       catch (Exception e) //或者Exception e，Exception e是捕获所有的

       {

           //要输出异常的信息，利于排错

         

           System.out.println("message:="+e.getMessage());

 

           e.printStackTrace();

           //处理

       }

//     catch (IOException e2)

//     {

//         e2.printStackTrace();  

//     }

       finally

     

       {

           System.out.println("进入finally");

           //这个语句块，不管有没有异常，都会执行

           //一般说，把需要关闭的资源[文件，连接，内存……]

           if(fr!=null)

           {

              try {

                  fr.close();

              } catch (IOException e) {

                  // TODO Auto-generated catch block

                  e.printStackTrace();

              }

           }

       }

//   

       System.out.println("kankan");

     

       //2.连接一个192.168.12.12  ip的端口号：4567

     

       //Socket s=new Socket("192.168.0.1",78);

     

       //运行异常

       //int a=4/0;

       //数组越界

       //int arr[]={1,2,3};

    //  System.out.println(arr[23]);

    }

 

}

9.抛出异常：

package com.test1_1;

import java.io.FileReader;

 

public class Demo7_7

{

 

    public static void main(String[] args) throws Exception

    {

       Father father=new Father();

       father.test1();

    }

 

}

 

class Father

{

    private Son son;

  

    public Father()

    {

       son=new Son();  

    }

    public void test1() throws Exception

    {

       System.out.println("1");

       try {

       son.test2();

       } catch (Exception e) {

           System.out.println("父亲");

           e.printStackTrace();

       }

    }

 

}

 

class Son

{

    public void test2() throws Exception

    {

       FileReader fr=null;

       fr=new FileReader("d:\\123d4.txt");     

    } 

}

10.泛型可以更安全和提高代码重用率，泛型可以利用反射机制拿到类的一系列信息，从而提高代码的优越性。

 

第二十七讲 作业讲评

跳水成绩打分系统

第二十八讲 作业讲评

1.静态变量不给初值也是可以的，默认为0，如果前面有final就一定要赋值了

2.布尔值之间可以用”==”号

3.if（i==1 & j==2）// 由于”i==1”返回了布尔值，所以就可以过去,否则就不行，但是c中就没有这样的顾虑，c会自动转换成boolen

4.继承中不能缩减被继承的父类中函数的范围（针对函数的参数的范围）

5.  Math.floor -> 取一个比某数小的最大整数

    Math.round -> 四舍五入

    Math. ceil ->取一个比某数大的最小整数   //ceil:天花板

Math.min-> 需要两个数被操作

6.substring(beginIndex,endIndex)——>起始索引包括，结束索引不包括

7.字符串的序数也是从0开始计数

8.Java的内存区分为：代码区、栈区和堆区

9.普通变量定义和初始化的时候直接放在栈区，不是普通变量的引用在栈区，对象在堆区

10.类中含有静态变量（函数）时候：直接在数据区（申请空间）

11.堆区中有字符串引用池（string pool），它存放字符串的引用，当字符池发现有字符时就指向字符，字符是存放在堆区中的。相同的字符串指向相同的地址，但是如果要用new来初始化，地址就不一样了，因为new是直接去开辟堆区的空间的。

12.对于对象来讲，==是比较地址

13.a.equals(b)区分大小写，a.equalsIgnoreCase(b)就不区分大小写

14.如果希望在子类中调用父类的构造函数，那么一般要求在子类的构造函数中调用

15. super表示当前正要调用该类它父类的变量或方法。

 

第二十九讲  满汉楼.swing介绍.（开始进入图形界面）

1.gui—>goo e(读音)Graphic user interface

2.       AWT（抽象窗口工具集）Abstract Window ToolKit

——>swing，解决了awt存在的Icd问题，是awt的继承和发展

——>IBM认为swing比较消耗内存，就创建了一个新的GUI库，叫SWT

    ——>IBM为了开发方便，又开发了更易用，功能强大的JFace

3.

Eclipse最早是IBM附属公司oti开发的，一共投入了4000万美金，后来捐献给开源社区

    Eclipse是一个开源的、可扩展的集成开发环境，已经成为最流行的java开发工具

    Eclipse安装就可以开发Java se，不能开发java ee项目，要安装MyEclipse或者lomboz

4.IDE：集成开发环境，比如jcreator、vs2005

5.sun公司开发的netbean，波兰的公司的Jbuilder，还有更早的Jcreator，IBM的J2SE开发+Myeclipse

 

6.swing组件：

 

 

7.  JFrame是Frame的子类

    属于容器类组件，顶层容器

    JFrame有一些常用的方法

8.JButton组件（也是一种容器）：是AbstractButton的子类，可以加入别的组件

9.由于组件会很多，以后就现在类的开始声明，然后再在构造函数里面先创建，再添加！

 

第三十讲 布局管理器

1.布局管理器：

概念：组件在容器中的位置和大小是由布局管理器来决定的，所有的容器都会使用一个布局管理器，通过它来自动进行组件的布局管理

    种类：java提供了五种布局管理器：流式布局管理器（FlowLayout）；边界布局管理器（BorderLayout）；网格布局管理器（GridLayout）；卡片布局管理器（CardLayout）、网格包布局管理器（GridBagLayout），前三种最常见

2.边界布局将容器简单的划分为东南西北中5个区域，中间区域最大

3.JFrame和JDialog窗体默认是边界布局

 如：

 

 

 

package com.GUI;

import java.awt.*;

import javax.swing.*;

 

public class Demo8_2 extends JFrame

{

  

    JButton jb1,jb2,jb3,jb4,jb5;

 

  

    public static void main(String[] args)  

    {

       Demo8_2 demo8_2=new Demo8_2();

    }

  

    public Demo8_2()

    {

     

       jb1=new JButton("中部");

       jb2=new JButton("北部");

       jb3=new JButton("东部");

       jb4=new JButton("南部");

       jb5=new JButton("西部");

     

       //添加各个组件

       this.add(jb1,BorderLayout.CENTER);

       this.add(jb2,BorderLayout.NORTH);

       this.add(jb3,BorderLayout.EAST);

       this.add(jb4,BorderLayout.SOUTH);

       this.add(jb5,BorderLayout.WEST);

     

       //设置窗体属性

       this.setTitle("边界布局");

       this.setSize(200,200);

       this.setLocation(200,200);

       this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

       //显示窗体

       this.setVisible(true);

    }

}

4.流式布局：FlowLayout，按照组件的添加次序将按钮组件（当然也可以是别的组件）从左到右放到容器中，当到达容器的边界时，组件放置到下一行中，FlowLayout可以以左对齐右对齐和居中对齐的方式排列组件。

5.流式布局注意：

    流式布局不限定它所管理的组件大小，允许他们有最佳大小

    当容器被缩放的时候，组件的位置可能变化，但是组件的大小不变

    默认组件是居中对齐，可以通过FlowLayout(int align)函数来指定对齐方式

 

 

 

package com.GUI;

 

import java.awt.*;

import javax.swing.*;

public class Demo8_3 extends JFrame

{

    JButton jb1,jb2,jb3,jb4,jb5,jb6;

  

    public static void main(String[] args)

    {

        Demo8_3 demo8_3= new Demo8_3();

 

    }

 

    public Demo8_3()

    {

        jb1=new JButton("aaa");

        jb2=new JButton("bbb");

        jb3=new JButton("ccc");

        jb4=new JButton("ddd");

        jb5=new JButton("eee");

        jb6=new JButton("fff");

      

        //添加组件

        this.add(jb1);

        this.add(jb2);    

        this.add(jb3);    

        this.add(jb4);    

        this.add(jb5);

        this.add(jb6);

        //设置布局管理器

        this.setLayout(new FlowLayout(FlowLayout.RIGHT));//设置位置

        //显示

        this.setTitle("流式布局案例");

        this.setResizable(false);//设置大小不变

        this.setLocation(200, 300);

        this.setSize(200, 300);

        this.setDefaultCloseOperation(EXIT_ON_CLOSE);

        this.setVisible(true);

      

    }

  

}

6.GridLayout将容器分成多行多列，组件被填充到每个网格中，添加到容器的组件首先放置在左上角的网格中，然后从左到右放置其它的组件，当占满该行的所有网格后，接着继续在下一行从左到右放置组件

7.对象数组在创建的时候要先new一下，然后再在赋值的时候new一下；简单数据类型就不需要这么麻烦的

8.

 

package com.GUI;

import java.awt.*;

import javax.swing.*;

 

public class Demo8_4 extends JFrame

{

    int size=9;

    JButton jbs[]=new JButton[size];

  

    public static void main(String[] args)

    {

     

       Demo8_4 demo8_4=new Demo8_4();

     

    }

 

    public Demo8_4()

    {

       for (int i=0;i<size;i++)

       {

           jbs[i]=new JButton(String.valueOf(i));      

       }

     

       //设置网格布局

       this.setLayout(new GridLayout(3, 3,10,10));//行和列

       for (int i=0;i<size;i++)

       {

           this.add(jbs[i]);      

       }

        //设置窗体属性

       this.setTitle("网格布局属性");

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setLocation(200, 200);

       this.setSize(200, 300);

       this.setVisible(true);

    }

  

}

9.网格布局的注意事项：

    组件的相对位置不随容器的缩放而变化，但是大小会变化

    所有组件的大小相同

    可以通过GridLayout（int rows ,int cols,int hgap,int vgap）来指定网格的行列，水平/垂直间隙

10.开发GUI程序步骤：

    继承JFrame

    定义需要的组件

    创建组件

    设置布局管理器

    添加组件

    显示窗体

 

第三十一讲 常用组件

1.面板组件（Jpanel）：布局管理器的组合使用

2.JPanel:面板组件，非顶层容器，一个界面只可以有一个JFrame窗体组件，但可以有多个JPanel组件，JPanel上可以使用FlowLayout、GridLayout、BorderLayout等各种布局管理器，使效果更复杂。

3.JPanel本身布局模式默认是FlowLayout

4.可以在JFrame上加JButton也可以在，JPanel上加JButton，在JFrame上 加JPanel

5.JPanel(面板)

    JPanel是JComponent的子类

    属于容器类组件，可以加入别的组件

    默认布局是流式布局

 

 

package com.GUI;

import java.awt.BorderLayout;

import java.awt.color.*;

import javax.swing.*;

 

public class Demo8_5 extends JFrame

{

    JPanel jp1,jp2;

    JButton jb1,jb2,jb3,jb4,jb5,jb6;

    public static void main(String[] args)

    {

       Demo8_5 demo8_5=new Demo8_5();

 

    }

 

    public Demo8_5()

    {

       //创建组件

       jp1=new JPanel();

       jp2=new JPanel();

      

       jb1=new JButton("西瓜");

       jb2=new JButton("苹果");

       jb3=new JButton("荔枝");

       jb4=new JButton("葡萄");

       jb5=new JButton("橘子");

       jb6=new JButton("香蕉");

        //设置布局管理器

       //添加JPanel

       jp1.add(jb1);

       jp1.add(jb2);

       jp2.add(jb3);

       jp2.add(jb4);

       jp2.add(jb5);

       jp2.add(jb6);

 

       this.add(jp1,BorderLayout.NORTH);

       this.add(jp2,BorderLayout.SOUTH);

       this.add(jb6,BorderLayout.CENTER);

     

       this.setSize(300, 200);

       this.setLocation(200, 300);

       this.setVisible(true);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

  

    }

  

}

6.文本框（JTextField）、密码框（JPasswordField）标签（JLable）

7. 多个组件的混合使用

  

package com.GUI;

import java.awt.*;

import javax.swing.*;

 

 

 

public class Demo8_6 extends JFrame

{

  

    JButton jb1,jb2;

    JPanel jp1,jp2,jp3;

    JTextField jtf;

    JPasswordField jpf;

    JLabel jl1,jl2; 

  

    public static void main(String[] args)

    {

       Demo8_6 demo8_6=new Demo8_6();   

    }

    public Demo8_6()

    {

     

       jp1=new JPanel();

       jp2=new JPanel();

       jp3=new JPanel();

       jb1=new JButton("确定");

       jb2=new JButton("取消");

       jtf=new JTextField(10);

       jpf=new JPasswordField(10);

       jl1=new JLabel("用户名");

       jl2=new JLabel("密     码");

 

       this.setLayout(new GridLayout(3,1));

     

       jp1.add(jl1);

       jp1.add(jtf);

       jp2.add(jl2);

       jp2.add(jpf);

       jp3.add(jb1);

       jp3.add(jb2);

     

       this.add(jp1);

       this.add(jp2);

       this.add(jp3);

     

       this.setSize(300,150);

       this.setVisible(true);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setLocation(200, 300);

    } 

}

8.同一组单选按钮必须先创建ButtonGroup，然后把单选框放入到ButtonGroup中

9.复选框组件（JCheckBox）单选框组件（JRadioButton）

10.对于单选框一定要把jrb1，jrb2加入到一个ButtonGroup中

11.

package com.GUI;

import java.awt.*;

import javax.swing.*;

public class Demo8_7 extends JFrame

{

  

    JButton jb1,jb2;

    JPanel jp1,jp2,jp3;

    JLabel jl1,jl2; 

    JCheckBox jcb1,jcb2,jcb3;

    JRadioButton jrb1,jrb2;

     

    public static void main(String[] args)

    {

       Demo8_7 demo8_7=new Demo8_7();   

    }

    public Demo8_7()

    {

     

       jp1=new JPanel();

       jp2=new JPanel();

       jp3=new JPanel();

       jcb1=new JCheckBox("足球");

       jcb2=new JCheckBox("篮球");

       jcb3=new JCheckBox("网球");

       jb1=new JButton("注册用户");

       jb2=new JButton("取消注册");

       jl1=new JLabel("你最喜欢的运动");

       jl2=new JLabel("你的性别");

       jrb1=new JRadioButton("男");

       jrb2=new JRadioButton("女");

     

       ButtonGroup bg=new ButtonGroup();

       bg.add(jrb1);

       bg.add(jrb2);

 

       //一定要把jrb1，jrb2加入到一个ButtonGroup中

 

       this.setLayout(new GridLayout(3,1));

     

       jp1.add(jl1);

       jp1.add(jcb1);

       jp1.add(jcb2);

       jp1.add(jcb3);

 

       jp2.add(jl2);

       jp2.add(jrb1);

       jp2.add(jrb2);

     

       jp3.add(jb1);

       jp3.add(jb2);

     

       this.add(jp1);

       this.add(jp2);

       this.add(jp3);

     

       this.setSize(300,150);

       this.setVisible(true);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setLocation(200, 300);

  

    } 

 

}

12. 下拉框组件JComboBox,先定义数组再将数组的名字作为参数加入

    列表框组件JList（默认直接全部展现出来）

    滚动窗格组件JScrollPanel

        String []dd={“12”，“23”，“34”}；

        jlist=new JList(dd)；

        jlist.setVisibleRowCount(2)；

        jsp=new JScrollPanel(jlist)；//将list放到滚动窗格里面

第三十二讲 swing编程实战

1.金山词霸

    拆分窗格：JSplitPane属于容器类组件

2. package com.GUI;

import java.awt.*;

import javax.swing.*;

 

public class Demo8_9 extends JFrame

{

       JSplitPane jsp;

       JList jList;

       JLabel jl1;

     

    public static void main(String[] args)

    {

 

       Demo8_9 demo8_9=new Demo8_9();

     

    }

 

 

 

public Demo8_9()

{

    String []words={"bird","girl","stupid","happy"};

    jList=new JList(words);

    jl1=new JLabel(new ImageIcon("images/ciba.gif"));

    //拆分窗格

    jsp=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,jList,jl1);

  

    //可以变化大小

    jsp.setOneTouchExpandable(true);

  

    this.add(jsp);

    this.setSize(200, 300);

    this.setVisible(true);

    this.setDefaultCloseOperation(EXIT_ON_CLOSE);

  

}

 

}

3.qq聊天界面 （涉及到swing组件）JTextArea：多行文本框工具

4.卡片布局 JTabbedPane选项卡窗格（页签组件）

5.QQ：

 

package com.GUI;

import java.awt.*;

 

import javax.swing.*;

 

public class Demo8_11 extends JFrame

{

    //北部区域

    JLabel jl1;

  

    //南部区域

    JButton jb1,jb2,jb3;

    JPanel jp1;

  

    //中部区域

    JTabbedPane jtp;

    JPanel jp2,jp3,jp4;

  

    JLabel jl2,jl3,jl4,jl5;

  

    //号码输入文本框

    JTextField jtf;

    //登录密码框

    JPasswordField jpf;

    //清除号码的Button

    JButton jb4;

     //隐身登陆、记住密码

    JCheckBox jcb1,jcb2;

  

  

    public static void main(String[] args)

    {

     

       Demo8_11 demo8_11=new Demo8_11();

    }

  

    public Demo8_11()

    {

       jl2=new JLabel("QQ号码",JLabel.CENTER);

       jl3=new JLabel("QQ密码",JLabel.CENTER);

       jl4=new JLabel("忘记密码",JLabel.CENTER);

     

       jl4.setFont(new Font("宋体",Font.PLAIN,16));

       jl4.setForeground(Color.BLUE);//设置字体颜色

     

       jl5=new JLabel("<html><a href='www.qq.com'>申请密码保</a>");

       jl5.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));//定义手型鼠标

     

       jtf=new JTextField();

       jpf=new JPasswordField();

       jb4=new JButton(new ImageIcon("clear.jpg"));

     

       //复选框

       jcb1=new JCheckBox("隐身登陆");

       jcb2=new JCheckBox("记住密码");

     

       //北部区域

       jl1=new JLabel(new ImageIcon("images\\tou.jpg"));

     

       //南部

       jp1=new JPanel();

       jb1=new JButton(new ImageIcon("images\\denglu.jpg"));

       jb2=new JButton(new ImageIcon("images\\quxiao.jpg"));

       jb3=new JButton(new ImageIcon("images\\xiangdao.jpg"));

     

       //中部区域

       jtp=new JTabbedPane();

       jp2=new JPanel();

       jp3=new JPanel();

       jp3.setBackground(Color.black);

       jp4=new JPanel();

       jp4.setBackground(Color.yellow);

     

       //将面板添加到选项卡窗格上

       jtp.add("QQ号码",jp2);

       jtp.add("手机号码",jp3);

       jtp.add("电子邮箱",jp4);

     

       //设置布局

       jp2.setLayout(new GridLayout(3, 3));

     

       //添加组件

       jp1.add(jb1);

       jp1.add(jb2);

       jp1.add(jb3);

     

       jp2.add(jl2);

       jp2.add(jtf);

       jp2.add(jb4);

       jp2.add(jl3);

       jp2.add(jpf);

       jp2.add(jl4);

       jp2.add(jcb1);

       jp2.add(jcb2);

       jp2.add(jl5);

     

       this.add(jp1,BorderLayout.SOUTH);

       this.add(jtp,BorderLayout.CENTER);

       this.add(jl1,BorderLayout.NORTH);

     

       this.setIconImage((new ImageIcon("images\\qq.jpg")).getImage());//给窗体设置图标

       this.setSize(330, 270);

       this.setLocation(350,250);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setVisible(true);

    }

}

6.记事本界面

涉及到菜单的组件

    菜单组件

        JMenuBar 菜单条组件 树干

        JMenu 菜单组件  树枝

        JMenuItem 菜单项组件 树叶

    二级菜单制作

        JMenu里面可以嵌套JMenu

    工具条组件

        JToolBar 容器类组件

第三十三讲 坦克大战

1.涉及到java的各个方面的技术：

    java面向对象编程

    界面编程

    绘图技术

    多线程

    文件I/O操作

    数据库

2.思考——编程——思考——编程

3.java的绘图坐标体系：以像素为单位，像素是计算机屏幕上最小的显示单位，x坐标表示为水平方向，y垂直方向

4.像素是一个密度单位

5.再面板上画一个小圆

6.绘图原理：

    Component类提供了两个和绘图相关最重要的方法

        paint（Graphics g）绘制组件的外观

        repaint()刷新组件的外观（展示动态）

7.当组件第一次在屏幕上显示的时候，程序会自动调用paint（）方法

8.以下情况paint（）会被调用

    窗口最小化，再最大化

    窗口的大小发生变化

    repaint函数被调用

9.Graphics提供了各种绘制图形的方法：

    画直线：drawLine(int x1,int y1,int x2,int y2);

    画矩形边框：drawRect（int x,int y,int width,int height）;

    填充矩形：fillRect（int x,int y,int width,int height）;

画圆：drawOval（int x,int y,int width,int height）;

    填充圆：fillOval（int x,int y,int width,int height）;

画图片：drawImage（Image img,int x,int y……）;

画字符串：drawString(String str,int x,int y);

设置画笔的字体：setFont(Font font);

设置画笔的颜色：setColor（Color c）;

……

10.

package com.test1;

import java.awt.*;

import javax.swing.*;

 

public class Demo9_1 extends JFrame

{

    MyPanel mp=null;

    public static void main(String[] args)

    {

     

       Demo9_1 Demo9_1=new Demo9_1();

     

    }

  

    public Demo9_1()

    {

       mp=new MyPanel();

     

       this.add(mp);

       this.setSize(400, 300);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setVisible(true);

    }

  

}

 

 

//定义一个MyPanel

class MyPanel extends JPanel

{

    //覆盖JPanel的paint方法

    //Graphics是绘图的重要类，相当于画笔

    public void paint(Graphics g)

    {

       //调用父类，完成初始化

       //此句话不能少！！！

       super.paint(g);

       System.out.println("paint被调用");

       //先画一个圆

       g.drawOval(10, 10, 30, 30);// 画圆

       //画出直线

       g.drawLine(100, 100, 200, 200);

       //画出矩形边框

       g.drawRect(10,10,40,60);

     

       //调整颜色

       g.setColor(Color.blue);

       g.fillRect(10, 10, 1200, 30);

       g.setColor(Color.red);

       g.fillRect(10, 100, 1200, 30);

     

       //在面板上画出图片,图片好像必须在src里面啊

       Image im=Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/1234.jpg"));

     

       //显示出来

       g.drawImage(im,90,90,200,150,this);

     

       //如何画字符串

       g.setColor(Color.red);

       g.setFont(new Font("隶书 ",Font.BOLD,50));

       g.drawString("祖国万岁", 180, 60);    

    } 

}

11.坦克大战，1.0版本，一般自己画图像，使用图片很耗资源

12.

package com.test1;

import java.awt.*;

import javax.swing.*;

 

public class MyTankGame1  extends JFrame

{

    MyPanel mp=null;

    public static void main(String[] args)

    {

       MyTankGame1 mytankgame1=new MyTankGame1();

     

    }

  

    public MyTankGame1()

    {

       mp=new MyPanel();

     

       this.add(mp);

       this.setSize(400,300);

       this.setVisible(true);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

     

    }

 

}

 

class MyPanel extends JPanel

{

    //定义我的坦克，成员变量

    Hero hero=null;

  

    public void paint (Graphics g)

    {

     super.paint(g);

     g.fillRect(0,0,400,300);

    

     this.drawTank(hero.getX(), hero.getY(), g, 0, 1);

    }

  

    public void drawTank(int x,int y,Graphics g,int direct,int type)

    {

       //判断类型

       switch (type)

       {

       case 0:

           g.setColor(Color.cyan);break;

       case 1:

           g.setColor(Color.yellow);break;  

       }

       //判断方向

     

       switch(direct)

       {

       //向上

       case 0:

            //画出我的坦克（到时候再封装成一个函数）

            //1.画出左面的矩形

            //g.drawRect(hero.getX(), hero.getY(), 5, 30);

            g.fill3DRect(x, y, 5, 30,false);

           

            //2.画出右边的矩形

            g.fill3DRect(x+15, y, 5, 30,false);

           

            //3.画出坦克的中间矩形

            g.fill3DRect(x+5, y+5, 10, 20,false);

            //画出中间的圆

            g.fillOval(x+4, y+10,10,10);

            //画出线

            g.drawLine(x+9, y+15, x+9, 5);

       break;

         

     

       }

     

     

     

    }

  

  

    public MyPanel()

    {

       hero=new Hero(10,10);     

    }

     

}

 

 

class Tank

{

    public int getX() {

       return x;

    }

 

    public void setX(int x) {

       this.x = x;

    }

 

    public int getY() {

       return y;

    }

 

    public void setY(int y) {

       this.y = y;

    }

 

    //表示坦克的横坐标

    int x=0;

    //坦克的纵坐标

    int y=0;

  

    public Tank(int x,int y)

    {

       this.x=x;

       this.y=y;

     

    }

  

}

 

//我的坦克

class Hero extends Tank

{

 

    public Hero(int x, int y)

    {

       super(x, y);

    }

  

}

 

第三十五讲 事件处理 坦克大战

1.画弧形：drawArc(100,200,120,300,50,100);

2.事件处理机制：java事件处理是采取“委派事件模型”，就是指产生事件的对象（事件源）会把此信息传递给事件的监听者处理的一种方式，而这里所说的信息实际上是java.awt.event 事件类库里某个类所创建的对象，我们暂时把它称为“事件的对象”

3.一个事件源可以有多个事件监听者

4.一个普通的类也是可以监听事件的

5.具体代码见博客

第三十六讲  时间监听  坦克大战

1.一个类要实现监听的步骤

    a.实现相应的接口（Keytener/MouseListener/ActionListener/WindowListener）

    b.把接口的处理方法根据需要重新编写

    c. 注册监听

    d.设置监听的command，setActionCommand(),getActionCommand()

2.人类的消息相当于java里面的事件对象

3.事件源：事件源是一个产生（或触发）事件的对象，当这个事件源对象的某些状态以某种方式发生变化时，就会产生某种类型的事件（一个事件源可能会产生多个不同类型的事件），如果某个组件（对象）希望得到事件源产生的事件，就需要在这个事件源上注册。

4.事件就是承载事件源状态改变时的信息对象，或者说，事件是事件源向事件监听器传输事件状态信息的载体。在用户与GUI组件进行交互时就会生成事件，比如当鼠标在面板上移动的时候就会生成一个鼠标移动事件的对象，而这个对象保存着当前鼠标在面板中位置信息。Java.awt.event包和javax.swing.event包定义了各种事件类型，常见的事件类型有：

    ActionEvent：按下按钮或者双击一个列表或选中某个菜单

    AdjustmentEvent：操作一个滚动条时

    ComponentEvent：当一个组件隐藏，移动，改变大小时候

    ContainerEvent：当一个组件从容器中加入或者删除

    FocusEvent：当一个组件获得或是失去焦点时候

    ItemEvent：当一个复选框或者是列表被选中，当一个选择框或者选择菜单被选中

    KeyEvent：当从键盘的按键被按下，松开时发生

    MouseEvent：当鼠标被拖动、移动、点击、按下……

    TextEvent：当文本框和文本域的文本发生改变时

    WindowEvent：当一个窗口激活、关闭、失效、恢复、最小化……

5.事件监听器接口：比如：implements ActionListener

    事件监听者就是一个类，事件监听器接口有多种，不同的事件监听器接口可以监听不同的事件，同一个类可以实现一个或者多个事件监听接口

6. package MyTest2;

 

import java.awt.*;

import javax.swing.*;

 

 

import java.awt.event.*;

 

public class Demo9_5 extends JFrame

{

    MyPanel mp=null;

  

    public static void main(String[] args)

    {

       Demo9_5 demo9_5=new Demo9_5();

    }

 

    //构造函数

    public Demo9_5()

    {

       mp=new MyPanel();

       this.addMouseListener(mp);

       this.addKeyListener(mp);

       this.addMouseMotionListener(mp);

       this.addWindowListener(mp);

       this.add(mp);

       this.setVisible(true);

       this.setSize(200, 300);

     

    }

  

}

//让MyPanel知道鼠标按下的消息，并且能知道点击位置的坐标

//让MyPanel知道哪个键按下了

//让MyPanel知道鼠标移动，拖拽

//让MyPanel知道窗口的变化（关闭、最大化、最小化）

 

class MyPanel extends JPanel implementsWindowListener,MouseListener,KeyListener,MouseMotionListener

{

    public void paint (Graphics g)

    {

       super.paint(g);

  

    }

 

    //鼠标点击

    public void mouseClicked(MouseEvent e) {

     

       System.out.println("鼠标x="+e.getX()+"  "+"y="+e.getY());

    }

 

    //鼠标移动到MyPanel

    public void mouseEntered(MouseEvent e) {

       System.out.println("鼠标来了！");

    }

 

    //鼠标离开

    public void mouseExited(MouseEvent e) {

     

    }

 

    //鼠标按下

    public void mousePressed(MouseEvent e) {

     

    }

 

    //鼠标松开

    public void mouseReleased(MouseEvent e) {

     

    }

 

    //键按下 没有松开

    public void keyPressed(KeyEvent e) {

       System.out.println(e.getKeyChar()+"键被按下");

     

    }

 

    //键松开

    public void keyReleased(KeyEvent e) {

     

    }

 

    //键输入，要求有具体的输入

    public void keyTyped(KeyEvent e) {

     

    }

 

    //鼠标拖拽

    public void mouseDragged(MouseEvent e) {

     

    }

 

    //鼠标移动

    public void mouseMoved(MouseEvent e) {

       System.out.println("鼠标x="+e.getX()+"  "+"y="+e.getY());

     

    }

 

    //窗口激活了

    public void windowActivated(WindowEvent e) {

       System.out.println("窗口激活了");

 

    }

 

    //窗口关闭了

    public void windowClosed(WindowEvent e) {

       System.out.println("窗口关闭了");

    }

 

    //窗口正在关闭

    public void windowClosing(WindowEvent e) {

       System.out.println("窗口正在关闭");

    }

 

    //窗口最小化

    public void windowDeactivated(WindowEvent e) {

     

    }

 

  

    public void windowDeiconified(WindowEvent e) {

     

    }

 

    public void windowIconified(WindowEvent e) {

     

    }

 

    //窗口打开了

    public void windowOpened(WindowEvent e) {

       System.out.println("窗口打开了");

    }

}

第三十七讲 事件总结 坦克大战5

1.事件处理机制的总结，如下：

java采用委托机制处理事件

java的事件是分类的

java中的一个类要监听某个事件，就必须实现相应的事件监听接口

事件监听接口有多种

在实现监听接口的类（事件监听类/者）中，需要重写处理函数

在事件源中需要注册事件监听类，否则事件监听类接收不到事件源发生的事件

2.代码，见博客，坦克大战——V2.0

 

第三十八讲 线程 坦克大战6

1.线程有：新建、就绪、运行、阻塞、死亡状态

2.运行中若资源突然不够用了，就阻塞，等待，一旦又满足条件了就进入就绪状态，如果还是可以满足条件，就再次进入运行状态；运行结束就死亡。

3.在java中，一个类要当作线程来使用有两种方法：

    继承Thread类，并重写run函数

    实现Runnable接口，并重写run函数（如果已经继承了别人的话，在不能多重继承的情况下使用接口 ）

第三十九讲 线程 坦克大战7（多线程）

1.多线程

package Thread2;

 

public class Demo10_3

{

 

    public static void main(String[] args)

    {

       Pig pig=new Pig(10);

       Bird bird=new Bird(10);

       Thread t1=new Thread(pig);

       Thread t2=new Thread(bird);

       t1.start();

       t2.start();

    }

 

}

 

 

 class Bird implements Runnable

{

    int n=0;

    int res=0;

    int time=0;

  

    public  Bird(int n)

    {

       this.n=n;       

    }

    public void run()

    {

       while(true)

       {

           try {

              Thread.sleep(1000);

           } catch (InterruptedException e) {

              e.printStackTrace();

           }

           res+=(++time);

           System.out.println("当前加上的值是"+ time);

           System.out.println("当前结果是"+res);

 

           if(time==n)

           {           

              System.out.println("最后结果是"+res);

              break;

           }                   

       }

    }

 

}

 

class Pig implements Runnable

{

    int n=0;

    int time=0;

    public void run()

    {

       while(true)

       {

           try {

              Thread.sleep(1000);

           } catch (InterruptedException e) {

              // TODO Auto-generated catch block

              e.printStackTrace();

           }

           time++;

           System.out.println("我是线程，在输出第"+time+ "个helloworld");

         

           if(time==n) break;

         

       }

  

    }

       public Pig(int n)

       {

           this.n=n;       

       }

}

2.  尽可能实现Runnable接口来创建线程

    在使用Thread的时候就只需要new一个实例出来，调用start（）方法就可以启动一个线程 Thread test =new Thread();test.start();

    在使用使用Runnable的时候，Test implements Runnable

Test t=new Test();Thread test=new Thread(t);test.start();

 

 

第四十讲 线程（深入理解）

1. 线程对象只能创建一个线程

2.多线程并发可能会导致线程安全问题：如：

    package Thread3;

 

public class Demo10_5

{

    public static void main(String[] args)

    {

       //定义三个售票窗口

       TicketWindow tw1=new TicketWindow();

       //TicketWindow tw2=new TicketWindow();

       //TicketWindow tw3=new TicketWindow();

 

       //使用三个线程同时启动

       Thread t1=new Thread(tw1);

       Thread t2=new Thread(tw1);

       Thread t3=new Thread(tw1);

     

       t1.start();

       t2.start();

       t3.start();

    }

}

 

class TicketWindow implements Runnable

{

    //一共两千张票

 

    private  int num=2000;

 

       public void run()

       {

           try

           {

              Thread.sleep(1000);

           }

           catch (InterruptedException e)

           {

              e.printStackTrace();

           }

 

         

           while(true)

           {

              //一秒钟出一张

                

              //先判断是否还有票

              if(num>0)

              {

                  //显示售票信息

                  System.out.println(Thread.currentThread().getName()+"在售出第"+num+"张票");

                  num--;             

              }

              else break;

           }

       }

}

3.解决问题的关键是保证容易出问题的代码的原子性，当一个进程在执行的时候别的进程只能等待其结束才能进行

4.Java进程同步做法：synchronized（Object）Object相当于是上厕所的门，就是所谓的对象锁，等待的线程就放在线程等待池里面，等待执行。

5.对象锁有0和1两个标志位，默认是1，变成0就说明其他的进程不能进入，就到等待池里面等待。

第四十一讲 坦克大战8

1.锁有对象锁和文件锁

2.synchronized（Object）//Object可以是任意类型的对象

3.写一个专门判断子弹是否击中的函数

4.什么地方调用该函数

 

第四十二讲 坦克大战9

1.爆炸效果

    先准备三张图片

    定义Bomb类

    在击中敌人的坦克时候，把炸弹放入向量中

    绘制

第四十三讲  I/O编程 坦克大战10

1.自己坦克被别人打死

2.控制坦克不重叠运动

3.解决保存问题，用文件和用数据库

4.文件在程序中是以流的形式来操作的

5.java设计者对流设计的不太好，流类太多（流泪啊）

6.字节流：以字节方式读写的流，可以读取二进制文件和任何类型的文件byte（InputStream，OutputStream）

    字符流：可以用于读写文本文件，不能操作二进制文件（Reader，Writer）

7.常见io流——文件对象

 

第四十四讲 io编程

1.创建文件用：f2.createNewFile();

    创建文件夹：f3.mkdir();

2.列出文件： File lists[]=f4.listFiles();

 

 

package IOStream;

import java.io.*;

 

public class Demo11_1

{

 

    public static void main(String[] args)

    {

       File f=new File("d:/a.txt");

       //得到文件的路劲

     

       System.out.println("文件路径："+f.getAbsolutePath());

       //得到文件的大小

       System.out.println("文件大小："+f.length());// 返回文件的字节大小

       System.out.println("可读："+f.canRead());//可不可读

       //创建文件和文件夹

       File f2=new File("d:\\hsp.txt");

       if(!f2.isFile())

       {

           //可以创建

           try {

              f2.createNewFile();

           } catch (IOException e) {

              e.printStackTrace();

           }

         

       }else

       {

           System.out.println("有文件不能创建");

       }

       //创建文件夹

       File f3=new File("d:\\ffddd");

       if(f3.isDirectory())

       {

           System.out.println("文件夹存在");

       }

       else

       {

           f3.mkdir();

       }

       //列出文件夹下面的所有文件

       File f4=new File("d:\\dd");   

     

       if(f4.isDirectory())

       {

           File lists[]=f4.listFiles();     

     

           for(int i=0;i<lists.length;i++)

           {

              System.out.println("文件名："+lists[i]);

           }

       }

       else

       {

           f4.mkdir();

       }    

    }

}

3.文件字节流

读取文件：FileInputStream，因为File没有读写能力，所以用个FileInputStream

4.记得关闭文件

 

package IOStream;

import java.io.*;

 

public class Demo11_2

{

 

    public static void main(String[] args)

    {

       File f=new File("d:\\test.txt");

       FileInputStream fis=null;

       try {

           //因为File没有读写能力，所以用个FileInputStream

           fis=new FileInputStream(f);

         

           //定义一个字节数组,相当于是缓存

           byte []bytes=new byte[1024];

           //得到实际读取到的字节数

           int n=0;

           //循环读取

           while((n=fis.read(bytes))!=-1)

           {

              //把字节转化成String

              String s=new String(bytes,0,n);

              System.out.println(s);        

           }

 

       }

       catch (Exception e)

       {

           e.printStackTrace();

       }

       finally

       {

           //关闭文件流要放在这里

           try

           {

              fis.close();

           }

           catch (IOException e)

           {

              e.printStackTrace();

           }

       } 

    }

}

5.

 

 

package IOStream;

import java.io.*;

 

public class Demo11_3

{

 

    public static void main(String[] args)

    {

       File f=new File("d:\\ss.txt");

     

       //字节输出流

       FileOutputStream fos=null;

       try

       {

           fos=new FileOutputStream(f);

           //如果数据量大的话，定义数组，把String转换成字节数组，这里就buy

         

           String s="12312231235555\r\n";//必须是回车再换行，注意顺序

           String s2="ddddddd";

 

           fos.write(s.getBytes());

           fos.write(s2.getBytes());

 

       }

       catch (Exception e)

       {

           e.printStackTrace();

       }

       finally

       {

           try {

              fos.close();

           } catch (IOException e) {

              // TODO Auto-generated catch block

              e.printStackTrace();

           }

       }

  

    }

 

}

第四十五讲  iO编程

1.图片拷贝

 

 

package com.test4;

 

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

 

public class Demo12_4

{

 

    public static void main(String[] args)

    {

       //先把图片读入到内存，再想办法将其写入某个文件

       //因我是二进制文件，因此只能用字节流完成

       FileInputStream fis=null;

       //定义输出流

       FileOutputStream fos=null;

       try

       {

           File f1=new File("c:\\a.jpg");

           fis=new FileInputStream(f1);

           fos=new FileOutputStream("d:\\a.jpg");

         

           byte buf[]=new byte[1024];

           int n=0;//记录实际读取的字节数

           //循环次数

       while((n=fis.read(buf))!=-1)

           {

              //输出到指定文件

              fos.write(buf);           

           }

         

         

       }

       catch (Exception e)

       {

           e.printStackTrace();

       }

       finally

       {

           try {

              fis.close();

              fos.close();

           } catch (IOException e) {

              // TODO Auto-generated catch block

              e.printStackTrace();

           }

         

       }

     

    }

 

} 

2.

 

3.

 

package com.test4;

import java.io.*;

public class Demo12_5

{

 

    public static void main(String[] args)

    {

       //文件取出字符流对象

       FileReader fr=null;

       //写入到文件

       FileWriter fw=null;

     

       try

       {

           //创建fr对象

           fr=new FileReader("c:\\ttt.txt");

           //创建输出对象

           fw=new FileWriter("d:\\ccc.txt");

           int n=0;//记录实际读取到的字符数

           char c[]=new char[1024];

           while((n=fr.read(c))!=-1)

           //read返回已经读取的数目，到了文件的末尾就返回-1，read本身有两种状态，要么刚读完返回c.length要么返回-1，所以相当于只有两个过程

           {

              System.out.println("n="+n);

              String s=new String(c,0,n);//从0开始读取n个

              System.out.println(s); 

               //fw.write(c);//写了所有的整块数据,1024的整数倍

              fw.write(c, 0, n);//按照实际长度写，不会有浪费的码

           }

       }

       catch (Exception e)

       {

           e.printStackTrace();

       }

       finally

       {

           try {

              fw.close();

              fr.close();

           } catch (IOException e) {

              // TODO Auto-generated catch block

              e.printStackTrace();

           }

          

         

       }

            

    }

}

4.常用IO流——缓冲字符流，直接操作String

    BufferedReader StreamReader

5.总结：

FileInputStream文件字节流：    File f=new File("d:\\test.txt");

                                FileInputStream fis=null;

    FileReader文件字符流：          fr=new FileReader("c:\\ttt.txt");

                                fw=new FileWriter("d:\\ccc.txt");

    BufferedReader缓冲字符流：    fr = new FileReader("c:\\ttt.txt");

    （读行）                      br=new BufferedReader(fr);

第四十六讲 IO编程 记事本开发

 

package com.test7;

import java.io.*;

import java.awt.*;

import javax.swing.*;

 

import java.awt.event.*;

 

public class NotePad extends JFrame implements ActionListener

{

    //定义需要的组件

    JTextArea jta=null;

    //定义菜单条

    JMenuBar jmb=null;

  

    //第一JMenu

    JMenu jm1=null;

 

    JMenuItem jmi1=null;

    JMenuItem jmi2=null;

  

    public static void main(String[] args)

    {

     

       NotePad notepad=new  NotePad();

       

    }

 

    public NotePad()

    {

        //创建jta

       jta=new JTextArea();

       jmb=new JMenuBar();

       jm1=new JMenu("文件");

       jm1.setMnemonic('F');

       jmi1=new JMenuItem("打开",new ImageIcon("weixiao.gif"));

       jmi2=new JMenuItem("保存",new ImageIcon("ziya.gif"));

 

        //注册监听

       jmi1.addActionListener(this);

        jmi1.setActionCommand("open");

     

        //对保存菜单的操作

        jmi2.addActionListener(this);

        jmi2.setActionCommand("save");

      

      

       jm1.add(jmi1);

       jm1.add(jmi2);

     

       jmb.add(jm1);

     

       this.setJMenuBar(jmb);

     

       //放入到JFrame

       this.add(jta);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setSize(400, 300);

       this.setVisible(true);

     

    }

 

    public void actionPerformed(ActionEvent e)

    {

       //判断哪个菜单被选中

       if(e.getActionCommand().equals("open"))

       {

           //System.out.println("open");

           //使用JFileChooser

           JFileChooser jfc1=new JFileChooser();

           //设置名字

           jfc1.setDialogTitle("请选择文件：");

           jfc1.showOpenDialog(null);

           //显示

           jfc1.setVisible(true);

           //得到用户选择的文件路径

           String filename=jfc1.getSelectedFile().getAbsolutePath();

           //System.out.println(filename);//显示绝对路径

           FileReader fr=null;

           BufferedReader br=null;

           try

           {

              fr=new FileReader(filename);

              br=new BufferedReader(fr);

            

              //从文件中读取信息

              String s="";

              String allCon="";

              while((s=br.readLine())!=null)

              {

                  //输出到JTextFile

                

                  allCon+=(s+"\r\n");

                

              }

              //放置到JTextFile中

              jta.setText(allCon);

           }

           catch (Exception e1)

           {

              e1.printStackTrace();

           }

           finally

           {

            

              try {

                  br.close();

                  fr.close();

              } catch (IOException e1) {

                  // TODO Auto-generated catch block

                  e1.printStackTrace();

              }

            

           }

         

       }

       else if (e.getActionCommand().equals("save"))

       {

           JFileChooser jfc2=new JFileChooser();

           jfc2.setDialogTitle("另存为…");

           jfc2.showSaveDialog(null);

           //按默认的方式显示

           jfc2.setVisible(true);

         

           //得到用户希望把文件保存到何处

           String file=jfc2.getSelectedFile().getAbsolutePath();

           //准备写入到指定的文件

         

           FileWriter fw=null;

           BufferedWriter bw=null;

         

           try

           {

              fw=new FileWriter(file);

              bw=new BufferedWriter(fw);

            

              bw.write(this.jta.getText());

           }

           catch (IOException e1)

           {

              e1.printStackTrace();

           }

           finally

           {

            

              try {

                  bw.close();

                  fw.close();

              } catch (IOException e1) {

                  // TODO Auto-generated catch block

                  e1.printStackTrace();

              }

            

           }

  

       }

    }

 

}

 

第四十六讲 io编程 记事本开发

 

package com.test7;

import java.io.*;

import java.awt.*;

import javax.swing.*;

 

import java.awt.event.*;

 

public class NotePad extends JFrame implements ActionListener

{

    //定义需要的组件

    JTextArea jta=null;

    //定义菜单条

    JMenuBar jmb=null;

  

    //第一JMenu

    JMenu jm1=null;

 

    JMenuItem jmi1=null;

    JMenuItem jmi2=null;

  

    public static void main(String[] args)

    {

     

       NotePad notepad=new  NotePad();

       

    }

 

    public NotePad()

    {

        //创建jta

       jta=new JTextArea();

       jmb=new JMenuBar();

       jm1=new JMenu("文件");

       jm1.setMnemonic('F');

       jmi1=new JMenuItem("打开",new ImageIcon("weixiao.gif"));

       jmi2=new JMenuItem("保存",new ImageIcon("ziya.gif"));

 

        //注册监听

       jmi1.addActionListener(this);

        jmi1.setActionCommand("open");

      

        //对保存菜单的操作

        jmi2.addActionListener(this);

        jmi2.setActionCommand("save");

      

      

       jm1.add(jmi1);

       jm1.add(jmi2);

     

       jmb.add(jm1);

     

       this.setJMenuBar(jmb);

     

       //放入到JFrame

       this.add(jta);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setSize(400, 300);

       this.setVisible(true);

     

    }

 

    public void actionPerformed(ActionEvent e)

    {

       //判断哪个菜单被选中

       if(e.getActionCommand().equals("open"))

       {

           //System.out.println("open");

           //使用JFileChooser

           JFileChooser jfc1=new JFileChooser();

           //设置名字

           jfc1.setDialogTitle("请选择文件：");

           jfc1.showOpenDialog(null);

           //显示

           jfc1.setVisible(true);

           //得到用户选择的文件路径

           String filename=jfc1.getSelectedFile().getAbsolutePath();

           //System.out.println(filename);//显示绝对路径

           FileReader fr=null;

           BufferedReader br=null;

           try

           {

              fr=new FileReader(filename);

              br=new BufferedReader(fr);

            

              //从文件中读取信息

              String s="";

              String allCon="";

              while((s=br.readLine())!=null)

              {

                  //输出到JTextFile

                

                  allCon+=(s+"\r\n");

                

              }

              //放置到JTextFile中

              jta.setText(allCon);

           }

           catch (Exception e1)

           {

              e1.printStackTrace();

           }

           finally

           {

            

              try {

                  br.close();

                  fr.close();

              } catch (IOException e1) {

                  // TODO Auto-generated catch block

                  e1.printStackTrace();

              }

            

           }

         

       }

       else if (e.getActionCommand().equals("save"))

       {

           JFileChooser jfc2=new JFileChooser();

           jfc2.setDialogTitle("另存为…");

           jfc2.showSaveDialog(null);

           //按默认的方式显示

           jfc2.setVisible(true);

         

           //得到用户希望把文件保存到何处

           String file=jfc2.getSelectedFile().getAbsolutePath();

           //准备写入到指定的文件

         

           FileWriter fw=null;

           BufferedWriter bw=null;

         

           try

           {

              fw=new FileWriter(file);

              bw=new BufferedWriter(fw);

            

              bw.write(this.jta.getText());

           }

           catch (IOException e1)

           {

              e1.printStackTrace();

           }

           finally

           {

            

              try {

                  bw.close();

                  fw.close();

              } catch (IOException e1) {

                  // TODO Auto-generated catch block

                  e1.printStackTrace();

              }

            

           }

  

       }

    }

 

}

 

第四十七讲 坦克大战11

第四十七讲 坦克大战11

第四十八讲 坦克大战12

第四十九讲 坦克大战13

1.存盘退出

* 画出坦克 4.0

 * 1.画坦克

 * 2.可以上下左右移动

 * 3.可以发子弹了

 * 4.可以连发子弹

 * 5.当我的坦克击中敌人的时候，敌人的坦克有爆炸效果

 * 6.放置敌人坦克重叠运动

 * 6.1决定把是否碰撞的函数

 * 7.可以分关

 *  7.1做一个开始的panel，它是一个空的，主要用于提示

 *  7.2字体闪烁

 * 8.可以再玩游戏的时候暂停和继续

 * 8.1当用户点击暂停的时候，子弹的速度和坦克的速度设置为0，而且让坦克的方向不发生变化

 * 9.可以记录玩家的成绩

 * 9.1用文件流的方式

 * 9.2单写一个记录类，对玩家的记录

 * 10.java如何操作声音文件

 

 

第五十讲 坦克大战14

 

详细的代码见 坦克大战4.0

2011年5月24日星期二

第五十一讲 作业评讲

第五十二讲 试题评讲

主要是复习以前的东西：

1.在try里面抛出异常和发生一般的异常是一样的，都会被catch住

2.final修饰的类不能被继承了

final修饰方法，该方法不能被覆盖

final 用于声明属性、方法和类，分别表示属性不可变，方法不可重写，类不可继承

3.

4.包的声明必须是源文件的第一句话

5.类的成员变量可以不赋初值，就是不初始化，但是如果是局部变量就需要给初值

6.字符串相比是比地址，如果字符串一样的话就是一样的地址

 

第五十三讲 数据库概念

1.用文件保存数据的缺点

    文件的安全性

    文件不利于查询和对数据的管理

    文件不利于存放海量数据

    文件在程序中控制不方便

2.数据库最早出现在1951年

3.数据库是按照数据结构来组织、存储和管理数据的仓库

4.数据库的基本结构

    物理数据层：数据库的最内层

    概念数据层：数据库的中间层，数据库的整体逻辑表示

    逻辑数据层：用户所看到和使用的数据库

5.数据库的不同特点

    实现数据共享

    减少数据的冗余度:维护数据的一致性

    实现数据集中控制：集中控制和管理，通过数据模型表示各种数据组织和数据间的联系

    数据的一致性和可维护性，以确保数据的安全性和可靠性

    故障恢复

6.  微软：sql server  access

    瑞典MySQL：AB公司mysql

    IBM公司：db2

    美国Sybase：Sybase

    IBM公司：informix

    Oracle公司：Oracle

7.  一流公司做标准（Intel、IEEE，在欧美的地方……）

    二流公司做服务（电信、中国移动……）

    三流公司做产品（用友、金蝶）

    四流公司做项目，针对（……）

    五流公司……

8.  小型数据库：access

    中型数据库：SQL Server、informix（安全，银行）

    大型数据库：Sybase、Oracle、MySQL

    海量数据库：DB2

9.数据库的选择：

    成本

    功能多少

    并发性（最终用户）

    安全性要求

10.sql server简单易用——>JDBC的开发

11.SQL：Structured Query Language（结构化查询语言）

12.ANSI：美国国家标准协会

13.Oracle、Sybase、SQL Server、access都用SQL语言

 

第五十四讲 sql Server安装配置卸载

1.sql server是一个关系数据库管理系统，1988年第一个OS/2版本

2.Sybase是在UNIX上运行的

3.sql server2000分为企业版、标准版、个人版、开发板

4.WindowsXP只能安装sql server2000个人版的

5.sql  server2000安装在XP上需要安装补丁sp4，总共要打15个补丁，安装在2000上就不需要安装补丁了

第五十五讲 sql server的基本使用

1.企业管理器：微软提供的图形界面方式操作sql server2000的工具

  查询分析器：微软提供的用命令行（sql语句）操作sql server2000的工具

2.数据对象包括表、触发器、存储过程……

3.  数据库用户

    管理员：

4.创建一个普通账户

5.建库、建表；

字段：表的列

    字段类型:列的类型

    表行：表的行

    表列：表的列

    记录：一行为一个记录

6.对表的增删改查

7.企业管理器虽然很方便，但是当表很大的时候或者要查询的时候就不方便了，用到了查询分析器

8.SQL是一种数据库查询和程序设计语言，用于存取数据和查询、更新以及管理关系数据库系统，开始是IBM的圣约瑟研究室为其关系数据库系统SYSTEM R开发的一种查询语言，它的前身是SQUARE语言，1981年IBM推出

9.SQL语言包括：

    数据定义语言（DDL）：create、drop、alter

    数据操作语言（DML）：insert、update、delete

    数据查询语言（DQL）：select语句

    数据控制语言（DCL）：grant、revoke、commit、rollback等

第五十六讲 查询分析器

1.创建数据库：create database LiangshanHero

2.创建表：--创建表

use LiangshanHero--使用某个数据库

go

create table hero-- 创建表

(heroID int,--英雄排名

heroName varchar(50),--名字

heroNickname varchar(50),--外号

sex char(2))

3.删除表 drop table 表名字

4.查询 select语句

5.删除表行：delete

6.补充：

①如果安装的时候，显示说有一个实例被挂起

运行——>reg-edit——>hekeylocalmachine_____system_____currentcontrolset______control_____session Manager，打开，删除pendingFileRename,加好了。

    ②数据库共享：通过新建sql server向导，可以实现数据库共享

 

 

 

--创建数据库-- 代表注释

create database LiangshanHero

--创建表

use LiangshanHero--使用某个数据库
go
create table hero-- 创建表
(heroID int,--英雄排名
heroName varchar(50),--名字
heroNickname varchar(50),--外号
sex char(2),
sal int
)

--删除一张表（把表的结构和表的数据一起删掉）

drop table hero

--使用sql语句来添加数据
insert into hero values(1,'宋江','及时雨','男',20000);
insert into hero values(2,'卢俊义','玉麒麟','男',15000);
insert into hero values(3,'吴用','智多星','男',30);
insert into hero values(4,'公孙胜','入云龙','男',80);

-- 查询
select  * from hero--最简单的查询语句

--查询工资低于100的

select * from hero where sal<100

--把工资低于100的人的薪水提高10%，用更新语句，update
--语法结构：update 表名 set 字段1=?,字段2=？…… where 条件

update hero set sal=sal*1.1 where sal<100

--删除语句，请删除工资性别为女的同志

delete from hero where sex='女'

第五十七讲 sql server 数据类型

1.表名和列的命名规则

         必须要以字母或者是下划线开头

         长度不要超过128字符

         不要使用sql server的保留字和关键字（真要是蓝色的就用[]包起来）

         只能使用字符：A-Z，a-z，0-9，$,#,_等等

2.支持的数据类型：

字符型：用来保存字符串的，char，定长，最大8000字符（非unicode编码）

（unicode编码：用两个字节表示一个字符，字符可以是英文字母，也可以是汉字，因此就统一了，因此对汉字支持就比较好了；非unicode是用一个字节表示字母，用两个字节表示汉字；big5码：表示繁体汉字的；iso-8859-1编码：支持欧文编码；gb2312（国标码）：针对中国汉字；gbk：支持更多的汉字；utf-8码；）

         char变量中未用完的空间用空占满

*当数据库的一个字段要存放定长的字段，那么用char的查询速度很快

3. varchar:最大8000字符，非unicode编码

4.ntext可变长unicode数据，最大长度是2的30次方-1，以多字节格式存储unicode的，也就是存储各种文字用的

5.text，可变长度非unicode，最大长度是2的31次方-1，以字节格式存储英文的，也可以存中文，有时候看中文会乱码

6.另外的字符型：

         nchar 定长，最大4000字符（unicode）

         nchar（10） 空格补全

         nvarchar 变长，最大4000字符（unicode编码）

         nvarchar（10），按需要分配，节约空间

7.一般带有汉字的段用nvarchar，全英文或符号的用varchar

8.      长度不定而且不超过4000字符有中文，用nvarchar，nvarchar处理汉字很快

         全英文的用varchar

9.数字型：

Bigint：从 -2^63 (-9,223,372,036,854,775,808) 到 2^63-1 (9,223,372,036,854,775,807) 的整型数据（所有数字）。

Int：从 -2^31 (-2,147,483,648) 到 2^31 - 1 (2,147,483,647) 的整型数据（所有数字）。

Smallint：从 -2^15 (-32,768) 到 2^15 - 1 (32,767) 的整型数据。

Tinyint：从 0 到 255 的整数数据。

bit 范围0到1的数

float:存放小数，不推荐使用

numeric：存放小数，推荐使用（表示成（n1，n2）n1表示总位数，n2表示小数位数，没有n2就表示整数了）

 

第五十八讲 数据类型

1.日期类型：datetime（表示日期）

                            Timestamp（时间戳）

create table sname

(

bir datetime

)

--sql server 提供了一个专门的时间函数getdate（）

insert into sname values(getdate())

select * from sname

2.图片，保存图片，很少用（软件公司：图片服务器（图床））

在图片有安全要求时，可以考虑放入数据库，而且图片不要太大

3.视频，binary存放，但是一般不这么做，一般放在文件服务器上。

4.sql server建议表的设计者，最好定义一个主键（primary key），用来唯一标示记录

create table clerk

(cleID int primary key,

cleName nvarchar(50),age int

)

insert into clerk values(1,'贾宝玉',18)

insert into clerk values(2,'贾政',18)

--插入部分字段要指定字段列表

insert into clerk (cleID,age)values(5,14)

insert into clerk values(4,'1234',null)

insert into clerk values(null,'111',null)

select * from clerk5.主键不能为空，必须赋值，而且不能重复

6.该字段：update 表名 set 表列 where 位置

         update clerk set age=38 where cleName='贾政'

7. --把2号的人名字改为薛蟠，age为40

update  clerk set cleName='薛蟠',age=40 where cleID=2

-- 主键可以修改不？？？可以修改，但是不能修改成已经存在的主键

update clerk set cleID=7 where cleName='薛蟠'

8.修改含有空值的数据（用is）

--把年龄为空的人改为'薛宝钗'

update clerk set cleName='薛宝钗' where age is null

9.      删除表 ：delete from 表名

删除字段：delete from 表名  where 字段名=’值’ and 字段名=’值’

如：delete from clerk where age>=70 and age<=75

delete from clerk where (age>=70 and age<=75) or age is null

10.表的查询：重点之重

使用（emp，dept）演示使用select语句

 

第五十九讲 基本查询

1.主键和外键

--创建一个新的数据库

create database spdb1

-- 创建dept表

create table dept

(

deptno int primary key ,

dname nvarchar(30),

loc nvarchar(30)

)

--创建emp表

create table emp

(

empno int primary key,

ename nvarchar(30),

job nvarchar(30),

mgr int,

hiredate datetime,

sal numeric(10,2),

comm numeric(10,2),

deptno int foreign key references dept(deptno)  --因为根据需要要做成外键

 

)

--针对外键，请注意

--1.外键只能指向主键

--2.外键和主键的数据类型要一致

insert into dept values (10,'shunping','new york')

insert into dept values (30,'jack','washington')

insert into emp values(7499,'allen','salesman',7698,'1981-2-20',1600.00,300.00,30)

select * from dept

select * from emp

2.      查询所有列：select * fromo 表名 from where 条件

         查询指定列：select 字段1，字段2 from 表名 where 条件（尽量不要用*）

         如何取消重复行：select distinct 字段 from 表名 where 条件

                   distinct 消除结果完全一样的行，保留一行

                   如：统计一共有多少个部门编号

3.sql server 2000不区分字母大小写

4.     --显示每个雇员的年工资

select ename,sal*13 年工资 from emp;--年工资是别名，可以加单引号或者双引号，或者什么都不加直接写

5.如何处理空的问题：运算中有null的时候结果就是null，可以用使用指定的替换值替换 NULL。语法ISNULL ( check_expression , replacement_value )

6.如何查询时间

         Select * from emp where hiredate>’1982-1-1’

7.between操作符：select *  from emp where sal between 1000 and 2500，包括两边的数

8.like操作符（模糊查询）：

         %：表示0到多个字符

         _:表示单个字符

第六十讲 基本查询

1.批量查询：select * from emp where empno=123 or empno=345 or ……

        我们就用in这个关键字来做，效率更高。Select * from emp where empno in(123,345)

2.使用is null的操作符

3.order by语句：默认是升序排列 asc（升序） desc（降序）

4. --按照部门升序而雇员的工资降序排列（可以根据不同的字段排序）

select * from emp order by deptno asc,sal desc

5.分页查询：

6.表的复杂查询：

         数据分组函数：max、min、avg、sum、count

7.能够迅速排查的东西写在右边，sql语句优化的原则，尽量将减少计算的过程写在右边，从右向左

8.GROUP BY子句    HAVING子句

9.当查询一般的字段和函数返回的值时候要用GROUP BY语句

10. --如何显示平均工资和最高工资 GROUP BY

select avg(sal),

select avg(sal),max(sal),deptno from emp group by deptno

11.having往往和group by结合使用，可以实现对分组查询到的结果进行筛选,并可以排序

select avg(sal),deptno from emp group by deptno having avg(sal)<2000

order by avg(sal) desc

12.显示平均工资低于2000的部门号和它的平均工资

select avg(sal),deptno from emp group by deptno having avg(sal)<2000

13.总结：

         ·分组函数只能出现在选择列表、having、order by子句中

         ·顺序：group by 、having、order by

         ·在选择列中如果有列、表达式和分组函数，那么这些列和表达式必须出现在group by子句中，否则报错，反过来group by中的字段也一定要出现在前面的select列表中

 

 

第六十一讲 复杂查询（多表查询）

1.多表查询是指基于两个或者两个以上的表或是视图的查询

2.笛卡尔积：select * from emp,dept

3.如果两张表有相同的字段，就需要带上表名或者用别名

select ename,sal,loc,e.deptno from emp e,dept d where d.deptno=e.deptno

4.凯文·米特尼克：黑客

5.      自连接：同一张表上的连接查询

显示某个员工的上级和他的上级名字

select  ename from emp where empno=(select mgr from emp where ename='blue')

6.对于自连接可以考虑将表分开的意思，看成两张表

select worker.ename 雇员,boss.ename 老板 from emp worker,emp boss where worker.mgr=boss.empno

7.子查询是指嵌入在其它sql语句中的select语句，也叫嵌套查询

8.单行子查询：返回单行数据的子查询。select * from emp where deptno=(select deptno from emp where ename='lucy')

9.多行子查询：返回多行数据的子查询

         --查询和部门10的工作相同的雇员的名字岗位工资部门号

select * from emp where job in (select distinct job from emp where deptno=10)

排除10号部门的：

select * from emp where job in (select distinct job from emp where deptno=10) and deptno!=10

10.在from子句中使用子查询？？？

第六十二讲 复杂查询

1.如何显示高于部门平均工资的员工的信息，相当于是：1.首先知道各个部门的平均工资

--将1的结果当做一个临时的表

         select emp.ename,emp.sal,tmp.myavg from emp,(select avg(sal) myavg,deptno from emp  group by deptno) tmp where emp.deptno=tmp.deptno and emp.sal>tmp.myavg

当在from子句中使用子查询时候，该子查询会被作为一个临时表来对待，当在from子句中使用子查询时候必须给予查询指定别名

2.分页查询，按照雇员id号升序取出

3. -- 请显示第2个到第4个入职的雇员，按照时间的先后顺序，如下：

--top后面的数代表要取出几条记录

select top 3 * from emp where empno not in (select top 1 empno from emp order by hiredate) order by hiredate

4.identity（1,1）：表示该字段testID是自增长的，从1开始每次加1

5. --疯狂的添加数据,测试性能

create table test (

testId int primary key identity(1,1),

testName varchar(30),

testPass varchar(30)

)

insert into test(testName,testPass) values('shunping','shunping')

insert into test (testName,testPass) select testName,testPass from test;

6.

第六十二讲 复杂查询

1.如何显示高于部门平均工资的员工的信息，相当于是：1.首先知道各个部门的平均工资

--将1的结果当做一个临时的表

         select emp.ename,emp.sal,tmp.myavg from emp,(select avg(sal) myavg,deptno from emp  group by deptno) tmp where emp.deptno=tmp.deptno and emp.sal>tmp.myavg

当在from子句中使用子查询时候，该子查询会被作为一个临时表来对待，当在from子句中使用子查询时候必须给予查询指定别名

2.分页查询，按照雇员id号升序取出

3. -- 请显示第2个到第4个入职的雇员，按照时间的先后顺序，如下：

--top后面的数代表要取出几条记录

select top 3 * from emp where empno not in (select top 1 empno from emp order by hiredate) order by hiredate

4.identity（1,1）：表示该字段testID是自增长的，从1开始每次加1

5. --疯狂的添加数据,测试性能

create table test (

testId int primary key identity(1,1),

testName varchar(30),

testPass varchar(30)

)

insert into test(testName,testPass) values('shunping','shunping')

insert into test (testName,testPass) select testName,testPass from test;

6.删除表中的重复记录

create table cat (catId int,catName nvarchar(40))

insert into cat values(1,'aa')

insert into cat values(2,'bb')

select * from cat

select distinct *  into #temp from cat

select * from #temp

delete from  cat

insert into cat select * from #temp

select * from cat

drop table #temp

7.左外连接、右外连接

         显示公司每个员工和他上级的名字

左外连接（left join）：左边的表的记录全部要出现，左边表的元素全部要出现，如果没有匹配的记录就用空来填

select w.ename b.ename from emp w left join emp where w.mgr=b.empno

         右外连接(right join)：右边的表的记录全部要出现，右边表的元素全部要出现，如果没有匹配的记录就用空来填

         内连接(inner join)：显示所有匹配的，不匹配的就不显示了

第六十三讲 约束

1.sql server 2000约束包括：

         not null:

         null意思是什么都没有，就像房子没有建起来，但是’’代表占空间了，就像房子建了但是里面没有什么东西

         unique:表示不允许重复，是唯一的，但是可以是空值，不过只能是放一个空值，两个空值代表是一样的值。同一个表中，主键只有一个，但是unique可以有多个。    

         表可以有复合组件多列联合起来作为主键。

--复合主键

create table test3

(

testId int,

testName nvarchar(30),

testPass nvarchar(30),

testage int,

primary key(testId,testName)—表级定义（还有行级定义）

)

foreign key(外键)：用于定于主表和从表的关系，外键的约束要定义在从表上，主表则必须具有主键约束或是unique约束，当定义外键约束后，要求外键列数据必须在主表的主键列存在或是null。

主表的记录可以被从表多条记录指向，但反过来就不行。

         check:用于强制行数据必须满足的条件。

         default:给值就按照你给的值，不给值就按照默认的值

         create table mes

(

mesId int primary key identity(1,1),

mescon varchar(2000),

mesDate datetime default getdate()

 

)

insert into mes(mescon) values('你好')

 

select * from mes

2.企业管理器的关系图的使用

3.添加一个字段

第六十四讲 备份恢复

1.crud      create       r（retrieve）——查询  update       delete        增删改查           增查改删

2.使用企业管理器实现备份和恢复，分离、附加

分离：（分离过后：数据库名.mdf          数据库名.ldf）

E:\Program Files\Microsoft SQL Server\MSSQL\Data     

附加：重新恢复，继续使用。选择mdf文件

3.真正的备份和恢复，把某个数据库从sql server上分离出来，用户可以根据需要使用

4.使用查询分析器完成备份和恢复：（前提条件是最好别使用aa这个数据库） 

--如何备份数据库

 backup database aa to disk='d:/sp.bak'

         --如何删除数据库

drop database aa

--如何恢复数据库

restore database aa from disk='d:/sp.bak'

--有时候你可能不需要备份整个数据库，而是只需要备份表

5.java操作sql server（CRUD）主要被用在描述系统的额

6.ODBC：开放的数据库接口（接口就是一堆函数）

7.jdbc（Java Data Base Connectivity）：

jdbc-odbc开发：jdbc（sun自己写的）——>odbc接口——>操作数据库

         纯jdbc：微软自己提供来支持java的，让java调用的

Jdbc也是商标名

当然针对不同的数据库，相应的jdbc是有区别的，连接用的驱动程序不一样

8.jdbc驱动分类：

jdbc-odbc桥连接

         本地协议纯java驱动程序

         网络协议纯java驱动程序

         本地API

9.jadbc不足：不同数据库有差异，为了更好实现跨数据库操作，使用Hibernate项目，实现对数据库的更宽泛的统一和好的移植性

10. .配置数据源，开始--控制面板--管理工具--数据源

 

 

 

 

 

选择.或者写local

11.代码：

 

package com.test1;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.SQLException;

import java.sql.Statement;

public class Test1

{

    public static void main(String[] args)

    {

       Connection ct=null;

       Statement sm=null;

       try {

           //1.加载驱动

           Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

           //得到连接

           //如果配置数据源的时候现则了windows NT方式就不要sa，sa了

       //就是Connection

// ct=DriverManager.getConnection("jdbc:odbc:mytest");

       ct=DriverManager.getConnection("jdbc:odbc:mytest","sa","sa");

           //创建Statement或者是PreparedStatement[区别]

           //Statemen的用处是：主要是要于发送sql语句到数据库

           sm=ct.createStatement();

           //执行数据库的crud

           //演示添加一条数据库到dept表

           //executeUpdate可以执行cud操作,有一个返回改变多少数据库记录的值

           int i=sm.executeUpdate("insert into dept values('50','保安部','西永')");

         

           if(i==1)   System.out.println("添加OK");

           else       System.out.println("添加error");

       } catch (Exception e){

           e.printStackTrace();

       }

       finally

       {

           //关闭资源

           try {

              if(sm!=null)

              {

              sm.close();

              ct.close();

              }

           } catch (SQLException e) {

              e.printStackTrace();

           }

       }

    }

}

 

第六十五讲 sql server jdbc

1.sql server里面都用单引号没问题的

2.显示ResultSet结果集，可以理解为表行的结果集，理解为游标，定义ResultSet rs，此时rs指向结果集的第一行的前一行，rs.getInt(1)，括号里面的数字是列，会报空指针，取出第一行的第一列用rs.next()，rs是按照行循环取出的，现在我们就循环取出，rs.next()。

3.Statement和PreparedStatement区别：

         ①Statement：直接将程序送到数据库

 

         ②PreparedStatement：它先预编译了一下再传送到数据库中，PreparedStatemen还t带有缓存机制，缓解数据库的压力，效率高，适合使用batch，比较好的解决系统本地化问题，而且能有效防止危险字符的注入，解决sql的注入漏洞问题。

         以后就用PreparedStatemen

4.     查询：              

ResultSet rs=sm.executeQuery("select * from dept");

                            while(rs.next())

                            {

                                     int deptno=rs.getInt(1);

                                     String dname=rs.getString(2);

                                     String loc=rs.getString(3);

                                     System.out.println(deptno+" "+dname+" "+loc);

                            }

5. --演示sql注入漏洞

create table users

(

username varchar(30),

passwd varchar(30)

)

insert into users values('aaa','aaa')

select * from users where username='aaa' and passwd='ffaa' or 1=1

6.用preparedStatement可以提高效率，不过要用问号，注入，才能防止注入漏洞

 

package com.test1;

import java.sql.*;

public class Test2

{

 

         public static void main(String[] args)

         {

                   //定义对象

                   PreparedStatement ps=null;

                   ResultSet rs=null;

                   Connection ct=null;

                   try {

                            //1.加载驱动

                            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");

                            //2.得到连接

                            ct=DriverManager.getConnection("jdbc:odbc:mytest","sa","sa");                     

                            //3.创建ps

                            ps=ct.prepareStatement("select * from dept where deptno=? and loc=?");

                            //给？号赋值

                            ps.setInt(1, 50);//第一个问号赋值为20

                            ps.setString(2, "西永");//第二个问号为dd

                            rs=ps.executeQuery();                        

                            while(rs.next())

                            {

                                     System.out.println(rs.getInt(1)+" "+rs.getString(2)+" "+rs.getString(3));                                  

                            }

                                                      

                   } catch (Exception e) {

                            e.printStackTrace();

                   }

                   finally

                   {

                            //关闭资源

                            try {

                                     if(rs!=null)

                                     {

                                               rs.close();

                                     }

                                     if(ps!=null)

                                     {

                                               ps.close();

                                     }

                                     if(ct!=null)

                                     {

                                               ct.close();

                                     }

                                   

                            } catch (SQLException e) {

                                     e.printStackTrace();

                            }                        

                   }               

         }

}     

第六十六讲 .sql-server jdbc

1.      如果使用jdbc-odbc不用引入包

         如果使用jdbc就要引入三个jar包：C:\Program Files\Microsoft SQL Server 2000 Driver for JDBC\lib

或者：http://www.microsoft.com/downloads/zh-cn/details.aspx?FamilyID=99B21B65-E98F-4A61-B811-19912601FDC9

下载那个htm的文件，然后打开这个htm文件，点最下面的接受就能下载软件了。

         

 

 

 

package com.test2;

import java.sql.*;

public class Test3

{

 

    public static void main(String[] args)

    {

       //PreparedStatement[火箭车]

       PreparedStatement ps=null;

       Connection ct=null;

       ResultSet rs=null;

     

       try

       {

           Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

           //2.得到连接

      ct=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;databaseName=spdb1","sa","sa");         

           ps=ct.prepareStatement("select * from emp");

           rs=ps.executeQuery();

           //循环取出雇员的名字和薪水和他的部门的编号

           while(rs.next())

           {

              //如果是选择*就用：

              String name=rs.getString(2);

              float sal=rs.getFloat(6);

              int deptno=rs.getInt(8);

              System.out.println(name+" "+sal+" "+deptno);          

           }

       }

       catch (Exception e)

       {

           e.printStackTrace();

       }

       finally

       {

           //关闭资源

           try {

              if(rs!=null)

              {

                  rs.close();

              }

              if(ps!=null)

              {

                  ps.close();

              }

              if(ct!=null)

              {

                  ct.close();

              }

            

           } catch (SQLException e) {

              e.printStackTrace();

           }        

       } 

    }

}

2.上面的要注意编号

另外一种写法：   String name=rs.getString(”ename”);

              float sal=rs.getFloat(“sal”);

              int deptno=rs.getInt(“deptno”);

3.

 

 

package com.test2;

import java.sql.*;

public class Test3

{

 

    public static void main(String[] args)

    {

       //PreparedStatement[火箭车]

       PreparedStatement ps=null;

       Connection ct=null;

       ResultSet rs=null;

     

       try

       {

           Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

           //2.得到连接

      ct=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;databaseName=spdb1","sa","sa");         

           ps=ct.prepareStatement("select ename,sal,dname from emp,dept where emp.deptno=dept.deptno");

           rs=ps.executeQuery();

           //循环取出雇员的名字和薪水和他的部门的编号

           while(rs.next())

           {

              //如果是选择*就用：

              String name=rs.getString("ename");

              float sal=rs.getFloat("sal");

              String dname=rs.getString("dname");

              System.out.println(name+" "+sal+" "+dname);           

           }

       }

       catch (Exception e)

       {

           e.printStackTrace();

       }

       finally

       {

           //关闭资源

           try {

              if(rs!=null)

              {

                  rs.close();

              }

              if(ps!=null)

              {

                  ps.close();

              }

              if(ct!=null)

              {

                  ct.close();

              }

            

           } catch (SQLException e) {

              e.printStackTrace();

           }        

       } 

    }

}

4.实际开发中，在java程序中

5.一个计算机最多的端口数目：65535个

1433表示sql server的默认端口，oracle：1521；ssh：22；tomcat：8080；mysql：3306；ftp：21

6.

import java.sql.*;

public class Test2

{

 

    public static void main(String[] args)

    {

       PreparedStatement ps=null;

       Connection ct=null;

       ResultSet rs=null;

     

       try {

           //Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

              Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

              //得到连接

              //1433表示sql server的默认端口，oracle：1521；ssh：22；tomcat：8080；mysql：3306；ftp：21

          //ct=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;databaseName=spdb1","sa","sa");

               ct=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;databaseName=spdb1","sa","sa");

            

              //创建一个数据库

              ps=ct.prepareStatement("create database ddd");

              //备份数据库

              ps=ct.prepareStatement("backup database ddd to disk='D:\\1.bak'");

            

              //如果执行是ddl语句

              boolean b=ps.execute();

              if(!b)

              {

                  System.out.println("OK");

              }

              else

              {

                  System.out.println("not OK"); 

              }    

           }

           catch (Exception e)

           {

              e.printStackTrace();

           }

    }

}

第六十七讲 作业讲评

1.找出早于12年前受雇的员工

         select * from emp where datediff(year,hiredate,getdate())>12

2.以首字母大写的方式显示所有的员工姓名

Select upper(substring(cname,1,1))+lower(substring(cname,2,len(cname))) from emp

//len()后面减不减1牵涉到字符串后面的/0

3.修改查询分析器打开时候的默认数据库：exec sp_defaultdb 账号名, 默认数据库

第六十八讲 项目开发流程（sqlserver项目开发）

1.JUDE：用于建模，用于设计软件（Java and UML Developers Environment）

2.项目开发流程：（中国目前无统一规范，但是总体的流程差不多）

         ①.需求分析：充分理解客户对项目的要求（项目经理或者是专门写需求分析的人）

         ②设计阶段：形成需求分析文档，决定用什么技术或者是什么框架，用什么操作系统，数据库，设计文档，形成开发小团队（项目经理或者是架构师）

         ③编码阶段：程序员

         ④测试阶段：测试人员，测试工程师

         ⑤实施阶段：实施工程师，顺利做好环境

第六十九讲 学生管理系统1 项目分析

1.功能说明（使用use case图说明，UML（统一建模语言，用图形化的界面描述系统），可以使用两款开发工具来做建模，java——eclipse，uml——rational rose2003，uml——jude）

         astah:用例图：可以很清晰地描述系统有什么功能和角色

2.设计数据库

         学生表

 

字段名	类型	备注
stuId	varchar（30）	学生id
stuName	nvarchar（50）	学生名	not null
stuSex	nchar(1)	性别	男或者女，默认男
stuAge	int	所在系	>0
stuJg	nvarchar(20)	籍贯
stuDept	nvarchar(30)	所在系

3.设计界面（原型开发【先搞定界面，征求客户意见，再写代码】）

4.下载和安装astah professional并且到网页上注册，通过邮箱拿到key。

5.用例图：可以很清晰地描述该系统有什么角色和功能

时序图

类图

6.JTable的使用：

 

package com.test1;

import java.sql.*;

import java.util.*;

import java.applet.*;

import javax.swing.*;

import java.awt.Event;//事件监听

 

public class Test1 extends JFrame

{

         //rowData存放行数据，columnName存放列名

         Vector rowData,columnNames;

         JScrollPane jsp=null;

         JTable jt=null;

         public static void main(String[] args)

         {

                 

                   Test1 test1=new Test1();

                 

                 

         }

         //构造函数

         public Test1()

         {

                   columnNames=new Vector();

                   //设置列名

                   columnNames.add("学号");

                   columnNames.add("名字");

                   columnNames.add("性别");

                   columnNames.add("年龄");

                   columnNames.add("籍贯");

                   columnNames.add("系别");

                 

                   rowData=new Vector();

                   //rowData可以存放多行

                   Vector hang=new Vector();

                   hang.add("sp001");

                   hang.add("孙悟空");

                   hang.add("男");

                   hang.add("500");

                   hang.add("花果山");

                   hang.add("少林派");

                 

                   //加入到rowData

                   rowData.add(hang);

                 

                   //初始化JTable

                   jt=new JTable(rowData,columnNames);

       

                   //初始化jsp JScrollPane

                   jsp=new JScrollPane(jt);

                 

                   //把jsp放入到jframe

                   this.add(jsp);

                   this.setSize(400,300);

                   this.setVisible(true);

                   this.setDefaultCloseOperation(EXIT_ON_CLOSE);

                 

         }

}

 

7.

package com.test1;

 

import java.sql.*;

import java.sql.*;

import java.util.*;

import java.applet.*;

import javax.swing.*;

import java.awt.Event;//事件监听

 

public class Test2 extends JFrame

{

  

    //rowData存放行数据，columnName存放列名

    Vector rowData,columnNames;

    JScrollPane jsp=null;

    JTable jt=null;

    //连接数据库需要的 

    Connection ct=null;

    PreparedStatement ps=null;

    ResultSet rs=null;

     

    public static void main(String[] args)

    {    

       Test2 test2=new Test2();         

    }

    //构造函数

    public Test2()

    {

       columnNames=new Vector();

       //设置列名

       columnNames.add("学号");

       columnNames.add("名字");

       columnNames.add("性别");

       columnNames.add("年龄");

       columnNames.add("籍贯");

       columnNames.add("系别");

     

       rowData=new Vector();

       try {

           //加载驱动

           Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

      ct=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;databaseName=spdb1","sa","sa");

           ps=ct.prepareStatement("select * from stu");

           rs=ps.executeQuery();

          

           while(rs.next())

           {

              Vector hang=new Vector();

              hang.add(rs.getString(1));

              hang.add(rs.getString(2));

              hang.add(rs.getString(3));

              hang.add(rs.getInt(4));

              hang.add(rs.getString(5));

              hang.add(rs.getString(6));

              //加入到rowData

              rowData.add(hang);        

           }

                

       }

       catch (Exception e)

       {

 

           e.printStackTrace();

       }

       finally

       {

  

           try

           {

              if(rs!=null) rs.close();

              if(ps!=null) ps.close();

              if(ct!=null) ct.close();

     

           } catch (SQLException e) {

              e.printStackTrace();

           }           

       }

     

       //初始化JTable

       jt=new JTable(rowData,columnNames);

  

       //初始化jsp JScrollPane

       jsp=new JScrollPane(jt);

     

       //把jsp放入到jframe

       this.add(jsp);

       this.setSize(400,300);

       this.setVisible(true);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

                

    }

 

}

 

第七十讲 学生管理系统2

1.

package com.test1;

 

import javax.swing.*;

 

import java.awt.*;

import java.sql.*;

import java.util.*;

import java.awt.event.*;

 

public class Test3 extends JFrame

{

    //定义一些控件

    JPanel jp1=null,jp2=null;

    JLabel jl1;

    JButton jb1,jb2,jb3,jb4;

    JTable jt;

    JScrollPane jsp;

    JTextField jtf;

  

    Vector rowData,columnNames;

  

    Connection ct=null;

    PreparedStatement ps=null;

    ResultSet rs=null;

     

  

    public static void main(String[] args)

    {

       Test3 test3=new Test3();         

 

    }

    public Test3()

    {

       jb1=new JButton("查询");

       jb2=new JButton("添加");

       jb3=new JButton("修改");

       jb4=new JButton("删除");

 

       jl1=new JLabel("请输入姓名");

       jtf=new JTextField(10);

     

       jp1=new JPanel();

       jp2=new JPanel();

 

       jp1.add(jl1);

       jp1.add(jtf);

       jp1.add(jb1);

     

       jp2.add(jb2);

       jp2.add(jb3);

       jp2.add(jb4);

     

 

     

       columnNames=new Vector();

       //设置列名

       columnNames.add("学号");

       columnNames.add("名字");

       columnNames.add("性别");

       columnNames.add("年龄");

       columnNames.add("籍贯");

       columnNames.add("系别");

     

       rowData=new Vector();

       try {

           //加载驱动

           Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");

      ct=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;databaseName=spdb1","sa","sa");

           ps=ct.prepareStatement("select * from stu");

           rs=ps.executeQuery();

         

           while(rs.next())

           {

              Vector hang=new Vector();

              hang.add(rs.getString(1));

              hang.add(rs.getString(2));

              hang.add(rs.getString(3));

              hang.add(rs.getInt(4));

              hang.add(rs.getString(5));

              hang.add(rs.getString(6));

              //加入到rowData

              rowData.add(hang);         

           }

                

       }

       catch (Exception e)

       {

 

           e.printStackTrace();

       }

       finally

       {

  

           try

           {

              if(rs!=null) rs.close();

              if(ps!=null) ps.close();

              if(ct!=null) ct.close();

     

           } catch (SQLException e) {

              e.printStackTrace();

           }           

       }

     

       //初始化JTable

       jt=new JTable(rowData,columnNames);

  

       //初始化jsp JScrollPane

       jsp=new JScrollPane(jt);

       this.add(jp1,"North");//大小写不能瞎写啊

       this.add(jp2,"South");//大小写不能瞎写啊

     

       //把jsp放入到jframe

       this.add(jsp);

       this.setSize(400,300);

       this.setVisible(true);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setLocationRelativeTo(null);

     

    }

  

 

}

2. MIS（管理信息系统——Management Information System）系统 ，是一个由人、计算机及其他外围设备等组成的能进行信息的收集、传递、存贮、加工、维护和使用的系统。

3.TableModel

4.想办法把对表的操作封装成一个类

5. setModel(TableModel dataModel) ：将此表的数据模型设置为 newModel，并向其注册以获取来自新数据模型的侦听器通知

6. jt=new JTable(sm);把模型放到JTable里面去

7.一行为一个向量Vector，然后再在rowData中加入很多的这些向量，就是有了很多行了

8.从向量里面取出来 

//得到共有某行某列的数据

    public Object getValueAt(int row, int column) {

       return ((Vector)this.rowData.get(row)).get(column);

    }

发现表头没有数据，于是就在空白处右击选择source选择override/implements methos选择getColumnName

    public String getColumnName(int column)

{

       return (String)(this.columnNames.get(column));

    }

9.考虑多个构造函数

第七十一讲  学生管理系统3 增删版本

1.初步理解模式的概念（MV）

2.模式的概念

3.              if(e.getSource()==jb2)

                   {

                            StuAddDialog stuadddialog=new StuAddDialog(this,"添加学生",true);//必须是模式对话框！！！

                          

                            //添加完了以后要重新获得新的数据模型

                            sm=new StuModel();

 

                            jt.setModel(sm);//更新对话框，注意是重点！

                          

                          

                   }

分析：因为是true的话，那么只有用户点击才会退出JDialog，也才能执行下面的程序，而点击了以后，数据库就变更了，正好符合我们的要求；否则的话，在我们没有操作的时候就直接执行了下面的，显示的并没有更新，不错的设计！

4. JOptionPane.showMessageDialog(this, "请选择一行");//这个是弹出的对话框

 

第七十二讲 学生管理系统4 Model2模式

 

1.以上我们用的是model1模式（仅用于早期九几年）：

         最大特点：界面和和操作放在一起

         优点：开发简单、方便

         缺点：代码复用性差、可读性不好、可维护性不好

2.Model2模式：要达到界面和操作分离（一种程序的思想），将model1模式改成model2模式

         优点：代码复用性好、可读性好、可维护性好

         缺点：复杂性高

 

第七十三讲 学生管理系统5  dao sqlhelper

1.DAO：Data Access Object(对数据库的操作)

2.

第七十四讲 满汉楼系统1 项目分析

1.原型开发：用户——需求分析师——界面设计师(网页设计师、桌面设计师)——

2.需求文档

3.设计文档：根据界面设计数据库和表——技术、操作系统、模式、UML图

4.系统设计文档：

    一   设计概要

1，设计目的

2性能要求

环境要求 

Word的使用

二  界面设计

登陆界面设计

登陆界面

主界面

人事管理界面

登陆管理界面

菜谱管理;

报表统计界面

成本可库房管理界面

动画帮助界面

收款界面

三  系统木块分析

    画图面板类

    数据库连接类

    音乐控制类

四  数据库设计

4.1  本系统共有21张表(不算小项目了)

一个一个模块开发

4.2  数据表的连接关系

五  功能模块设计

闪屏

登陆

操作管理模块            收款界面

人事管理                预定位置

登陆管理                退订位置

菜谱价格管理            点菜系统

报表管理                结账服务

成本控制                客户服务

系统设置              

系统帮助              

然后在分别说明各个界面的作用

 

六  具体模块设计 (这里详细说明  字非常多详细说明每个Button的功能)

6.1管理界面设计

6.1.1主界面内容

6.1.2主界面功能

6.2人事管理

模块功能

模块界面说明

   各个功能详细说明

添加功能     新员工登记  修改功能 删除功能

收款界面:等等

第七十五讲 满汉楼系统2  项目分析

1.将数据库备份文件还原

第八十四讲 网络基础

第八十五讲  port.url.socket编程原理

1.      0是保留端口

1-1024是固定端口（有名端口），一般程序员不可以用

         22：ssh远程登录协议

         23：telnet使用

         21：ftp使用

         25：smtp使用

         80：iis使用

         7：echo服务使用

       

         1025-65535：动态端口，程序员可以使用

         1433：sqlserver

2.注意事项：在计算机中要尽可能少开端口

                     一个端口只能被一个程序监听

                     如果使用netstat  –an可以看那些端口在监听

                     使用netstat  –anb查看监听端口的进程ID号                  

3.完整的URL：协议、ip地址、端口号、资源名称

 

4.服务器端：

 

package com.test1;

 

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.*;

 

public class MyServer1

{

 

    public static void main(String[] args)

    {

       MyServer1 myServer1=new MyServer1(); 

    }

  

    public MyServer1()

    {        

       try {

           //在9999号端口监听

           ServerSocket ss= new ServerSocket(9999);       

           System.out.println("我是服务器，我在9999端口监听");

           //等待某个客户来连接，该函数会返回一个socket连接

           Socket s=ss.accept();

     

           //要读取s中传递的数据

           BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));      

           String info=br.readLine();       

           System.out.println("我是服务器，收到了来自客户端的信息，是："+info);

         

           PrintWriter pw=new PrintWriter(s.getOutputStream(),true);        

           pw.println("我是服务器，你也好");

         

       } catch (Exception e){

           e.printStackTrace();

       } 

    }

 

}

客户端：

 

package com.test1;

 

import java.net.*;

import java.io.*;

 

public class MyClient1

{

  

    public static void main(String[] args)

    {    

       MyClient1 myClient1=new MyClient1();

     

    }

    public MyClient1()

    {

       try {       

           //socket（）就是去连接某个服务器 127.0.0.1表示服务器的地址       

           Socket s=new Socket("127.0.0.1",9999);

         

           //如果s连接成功，就可以发送数据给服务器

           //通过pw向s写数据,true表示即时刷新数据流

           PrintWriter pw=new PrintWriter(s.getOutputStream(),true);

           pw.println("你好吗，我是客户端");

         

           BufferedReader br=new BufferedReader(new InputStreamReader(s.getInputStream()));      

           String response=br.readLine();       

           System.out.println("我是客户端，收到了服务器会送的信息，是："+response);    

       } catch (Exception e) {

           e.printStackTrace();

       }           

    } 

}

第八十六讲 半双工 全双工

1.单双工：

 

 * 一个服务器在9999端口上监听,可以通过控制台输入回送给客户端的信息

 

package com.test1;

 

import java.net.*;

import java.io.*;

 

public class MyServer2

{

 

    public static void main(String[] args)

    {

     

       MyServer2 myServer2=new MyServer2();

    }

  

    public MyServer2()

    {

       try {

           ServerSocket ss=new ServerSocket(9999);

         

           //等待连接

           Socket s=ss.accept();         

           InputStreamReader isr=new InputStreamReader(s.getInputStream());

           BufferedReader br=new BufferedReader(isr);

                    

           //接收从控制台输入的信息      

           InputStreamReader isr2=new InputStreamReader(System.in);

           BufferedReader br2=new BufferedReader(isr2);

 

           while(true)

           {

              String infoFromClient=br.readLine();

              System.out.println("客户端发来了："+infoFromClient);

              if(infoFromClient.equals("bye"))

              {

                  s.close();

                  System.out.println("通话结束！");

                  break;

              }

              //接收从控制台输入的信息

              System.out.println("请输入你希望对客户端说的话：");               

              String response=br2.readLine();

              PrintWriter pw=new PrintWriter(s.getOutputStream(),true);

 

              //把从控制台接收的信息回送给客户端

              pw.println(response);

            

              if(response.equals("bye"))

              {

                  s.close();

                  System.out.println("通话结束！");

                  break;

              }

           }

                   

           } catch (Exception e) {

           e.printStackTrace();

         

       }

     

    }

     

}

 

 

 * 客户端

 

package com.test2;

import java.io.*;

import java.net.*;

 

public class MyClient2

{

 

    public static void main(String[] args)

    {

     

       MyClient2 myClient2=new MyClient2();

     

     

    }

 

    public MyClient2()

    {

       try {

           Socket s=new Socket("127.0.0.1",9999);

         

           InputStreamReader isr=new InputStreamReader(System.in);

           BufferedReader br=new BufferedReader(isr);

 

           PrintWriter pw=new PrintWriter(s.getOutputStream(),true);

 

          

           InputStreamReader isr2=new InputStreamReader(s.getInputStream());

           BufferedReader br2=new BufferedReader(isr2);

         

         

           while(true)

           {

              System.out.println("请输入你想对服务器说的话");

              String info=br.readLine();

              pw.println(info);

              if(info.equals("bye"))

              {

                  s.close();

                  System.out.println("通话结束！");

                  break;

               }

              //从服务器接收的话

              String infoFromServer=br2.readLine();

              System.out.println("服务器发来了："+infoFromServer);

         

              if(infoFromServer.equals("bye"))

              {

                  s.close();

                  System.out.println("通话结束！");

                  break;

              }

           }

                   

       } catch (Exception e) {

           e.printStackTrace();

       }

     

    }

     

}

2.带界面的单双工：

 

 * 服务器端

 

package com.test1;

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.*;

import java.net.*;

import javax.swing.*;

 

public class MyServer3 extends JFrame implements ActionListener

{

    JTextArea jta=null;

    JTextField jtf=null;

    JButton jb=null;

    JScrollPane jsp=null;

    JPanel jp=null;

  

    PrintWriter pw=null;

    public static void main(String[] args)

    {

       MyServer3 myServer3=new MyServer3();

    }

 

    public MyServer3()

    {

       jta=new JTextArea();

       jtf=new JTextField(10);

       jb=new JButton("发送");

       jb.addActionListener(this);

       jsp=new JScrollPane(jta);

       jp=new JPanel();   

     

       jp.add(jtf);

       jp.add(jb);

 

       this.add(jsp);

       this.add(jp,BorderLayout.SOUTH);

     

       this.setVisible(true);

       this.setTitle("qq简易聊天，服务器端");

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setSize(300,200);

     

 

 

       try {

           ServerSocket ss=new ServerSocket(9988);

           Socket s=ss.accept();//在等待中……  

           //服务器监听

     

           //Socket s=ss.accept();//在等待中……

         

           InputStreamReader isr=new InputStreamReader(s.getInputStream());

           BufferedReader br=new BufferedReader(isr);

         

           pw=new PrintWriter(s.getOutputStream(),true);

 

           while(true)

           {

              String infoFromClient=br.readLine();

              jta.append("客户端对服务器说："+infoFromClient+"\r\n");

            

           }

                   

       } catch (Exception e) {

           e.printStackTrace();

         

       }

  

    }

 

    public void actionPerformed(ActionEvent e)

    {

       if(e.getSource().equals(jb))

       {

           //把服务器在jtf写的数据写在

           String info=jtf.getText();

           jta.append("服务器对客户端说："+info+"\r\n");     

           pw.println(info);

           jtf.setText("");

       }

    }

}

 

 

 

 *客户端

 

package com.test2;

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.*;

import java.net.*;

import javax.swing.*;

 

public class MyClient3 extends JFrame implements ActionListener

{

    JTextArea jta=null;

    JTextField jtf=null;

    JButton jb=null;

    JScrollPane jsp=null;

    JPanel jp=null;

    PrintWriter pw;

 

    public static void main(String[] args)

    {

       MyClient3 myClient3=new MyClient3();

    }

 

    public MyClient3()

    {

       jta=new JTextArea();

       jtf=new JTextField(10);

       jb=new JButton("发送");

       jb.addActionListener(this);

       jsp=new JScrollPane(jta);

       jp=new JPanel();   

     

       jp.add(jtf);

       jp.add(jb);

 

       this.add(jsp);

       this.add(jp,BorderLayout.SOUTH);

     

       this.setVisible(true);

       this.setTitle("qq简易聊天,客户端");

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setSize(300,200);

     

       try {

           Socket s=new Socket("127.0.0.1",9988);

           InputStreamReader isr=new InputStreamReader(s.getInputStream());

           BufferedReader br=new BufferedReader(isr);

         

           pw=new PrintWriter(s.getOutputStream(),true);

 

           while(true)

           {

              String infoFromServer=br.readLine();

              jta.append("服务器对客户端说："+infoFromServer+"\r\n");

                       

           }

         

       } catch (Exception e) {

           e.printStackTrace();

       }

            

    }

 

    public void actionPerformed(ActionEvent e)

    {

       String info=jtf.getText();

       jta.append("客户端对服务器说："+info+"\r\n");

       pw.println(info);

       jtf.setText("");   

    }

}

第八十七讲 山寨qq项目1.登录界面

* qq客户端登陆界面

package com.qq.client.view;

import java.net.*;

import java.awt.*;

import java.io.*;

import javax.swing.*;

 

public class QqClientLogin extends JFrame

{

    //北部的组件

    JLabel jl1;

  

    //中部的组件

    JTabbedPane jtp;

    JPanel jp2,jp3,jp4;

  

    JButton jb1;

    JLabel jl2,jl3,jl4,jl5,jl6;

    JTextField jtf; 

    JPasswordField jpf;

    JCheckBox jcb1,jcb2;

  

    //南部的组件

    JPanel jp1;

    JButton jb2,jb3,jb4;

 

    public static void main(String[] args)

    {

       QqClientLogin qqClientLogin=new QqClientLogin();

    }

  

    public QqClientLogin()

    {

       //处理北部

       jl1=new JLabel(new ImageIcon("images/tou.jpg"));

     

       //处理中部

     

       jp2=new JPanel(new GridLayout(3,3));

     

       jl2=new JLabel("QQ号码",JLabel.CENTER);

       jl3=new JLabel("QQ密码",JLabel.CENTER);

       jl4=new JLabel("忘记密码",JLabel.CENTER);

       jl4.setForeground(Color.blue);

       jl5=new JLabel("申请密码保护",JLabel.CENTER);

       jb1=new JButton(new ImageIcon("images/qingchuhaoma.jpg"));

            

       jp3=new JPanel();

       jp4=new JPanel();  

     

       //处理南部

       jp1=new JPanel();

            

       jb2=new JButton(new ImageIcon("images/denglu2.jpg"));

       jb3=new JButton(new ImageIcon("images/quxiaodenglu.jpg"));

       jb4=new JButton(new ImageIcon("images/xiangdao.jpg"));

       jtf=new JTextField();

       jpf=new JPasswordField();

       jcb1=new JCheckBox("隐身登陆");

       jcb2=new JCheckBox("记住密码");

       jtp=new JTabbedPane();

       jp3=new JPanel();

       jp4=new JPanel();

 

       //把控件按照顺序加到jp2

       jp2.add(jl2);

       jp2.add(jtf);

       jp2.add(jb1);

       jp2.add(jl3);

       jp2.add(jpf);

       jp2.add(jl4);

       jp2.add(jcb1);

       jp2.add(jcb2);

       jp2.add(jl5);

  

       jp1.add(jb2);

       jp1.add(jb3);

       jp1.add(jb4);

     

       jtp.add("QQ号码",jp2);

       jtp.add("手机号码",jp3);

       jtp.add("电子邮件",jp4);

  

       this.add(jl1,"North");

       this.add(jp1,"South");

       this.add(jtp,"Center");

     

       this.setSize(390,260);

       this.setVisible(true);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setLocationRelativeTo(null);

       this.setTitle("阿贵的QQ");

     

    }

 

}

第八十八讲 山寨qq项目2.好友列表界面

实现了简单的qq界面

 

 * qq好友、陌生人、黑名单

 

package com.qq.client.view;

 

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import java.io.*;

import javax.swing.*;

 

import javax.swing.JPanel;

 

public class QqFriendList extends JFrame implements ActionListener,MouseListener

{

 

    //处理第一张卡片

    JPanel jphy1,jphy2,jphy3;

    JButton jphy_jb1,jphy_jb2,jphy_jb3;

    JScrollPane jsp;

  

    //处理第二张卡片

    JPanel jpmsr1,jpmsr2,jpmsr3;

    JButton jpmsr_jb1,jpmsr_jb2,jpmsr_jb3;

    JScrollPane msr_jsp;

    //把整个JFrame设置成一个CardLayout布局

    CardLayout cl=null;

    public static void main(String[] args)

    {

       QqFriendList qqFriendList=new QqFriendList();

    }

    public QqFriendList()

    {

       //处理第一张卡片（显示好友列表）

       jphy1=new JPanel(new BorderLayout());

       //假定有50个好友

       jphy2=new JPanel(new GridLayout(50,1,4,4)); 

       //给jphy2初始化50个好友

       JLabel jlb[]=new JLabel[50];

     

       for(int i=0;i<jlb.length;i++)

       {

           jlb[i]=new JLabel(i+1+"",new ImageIcon("images/mm.jpg"),JLabel.LEFT);

           jlb[i].addMouseListener(this);

           jphy2.add(jlb[i]);

       }

            

       jphy3=new JPanel(new GridLayout(2,1));

       jsp=new JScrollPane(jphy2);

     

       jphy_jb1=new JButton("我的好友");

       jphy_jb2=new JButton("陌生人");

       jphy_jb2.addActionListener(this);

       jphy_jb3=new JButton("黑名单");

 

       jphy3.add(jphy_jb2,"Center");    

       jphy3.add(jphy_jb3,"South");

     

       jphy1.add(jphy_jb1,"North");

       jphy1.add(jsp,"Center");

       jphy1.add(jphy3,"South");

     

       //处理第二张卡片

 

       jpmsr_jb1=new JButton("我的好友");

       jpmsr_jb1.addActionListener(this);

 

       jpmsr_jb2=new JButton("陌生人");

       jpmsr_jb3=new JButton("黑名单");

     

       jpmsr1=new JPanel(new BorderLayout());

       //假定有20个好友

       jpmsr2=new JPanel(new GridLayout(20,1,4,4));

       //给jphy2初始化20个好友

       JLabel jlb2[]=new JLabel[20];

     

       for(int i=0;i<jlb2.length;i++)

       {

           jlb2[i]=new JLabel(i+1+"",new ImageIcon("images/mm.jpg"),JLabel.LEFT);

           jpmsr2.add(jlb2[i]);

       }

            

       jpmsr3=new JPanel(new GridLayout(2,1)); 

     

       jpmsr3.add(jpmsr_jb1);   //

       jpmsr3.add(jpmsr_jb2);//

     

       msr_jsp=new JScrollPane(jpmsr2);

 

     

       jpmsr1.add(jpmsr_jb3,"South");

       jpmsr1.add(msr_jsp,"Center");

       jpmsr1.add(jpmsr3,"North");

     

       cl=new CardLayout();

       this.setLayout(cl);

     

       this.add(jphy1,"1");

       this.add(jpmsr1,"2");

     

       this.setSize(220,550);

       this.setVisible(true);

       this.setDefaultCloseOperation(EXIT_ON_CLOSE);

       this.setLocation(800,1);

       this.setTitle("阿贵的QQ");

     

    }

    @Override

    public void actionPerformed(ActionEvent e)

    {

       if(e.getSource()==jphy_jb2)

       {

           cl.show(this.getContentPane(), "2");

       }

     

       if(e.getSource().equals(jpmsr_jb1))

       {

           cl.show(this.getContentPane(), "1");

  

       }

     

    }

    @Override

    public void mouseClicked(MouseEvent e) {

       // TODO Auto-generated method stub

       if(e.getClickCount()==2)

       {

           String friendNo=((JLabel)e.getSource()).getText();

           System.out.println("哈哈，我知道了，你想和"+friendNo+"聊天");

       }

    }

    @Override

    public void mouseEntered(MouseEvent e) {

       // TODO Auto-generated method stub

       JLabel jl=(JLabel)e.getSource();

       jl.setForeground(Color.red);

    }

    @Override

    public void mouseExited(MouseEvent e) {

       // TODO Auto-generated method stub

       JLabel jl=(JLabel)e.getSource();

       jl.setForeground(Color.black);

    }

    @Override

    public void mousePressed(MouseEvent e) {

       // TODO Auto-generated method stub

     

    }

    @Override

    public void mouseReleased(MouseEvent e) {

       // TODO Auto-generated method stub

     

    }

}

 

第八十九讲 山寨qq项目3.聊天界面 对象流

用对象流处理多个对象，在网络中传递对象

第九十讲 山寨qq项目4.登录验证

 

获得文本框和密码框的值的方法：（切记！！！）

   u.setUserId(jtf.getText().trim());
   u.setPasswd(new String(jpf.getPassword()));

 

第91讲-山寨qq项目5.一对一的聊天

1.服务器为了可以完成信息转发，可以将服务器得到的每一个socket和客户端保存在HashMap用客户的ID标示socket

2.当服务器和某个客户端形成一个连接时，服务器就开一个新的线程，让这个线程和客户端通讯