java基础语法笔记

java很多语法都跟C#类似，下面列举一些不同的地方******注意***** java中的系统方法首字母都是小写的，而C#中首字母都是大写的
1、java中继承的用法
　　class children extends parent
　　{
　　}
而c#中：
　　class children ：parent
　　{
　　}

java中继承接口的用法
　　class children implements parent
　　{
　　}
而c#中：
　　class children ：parent
　　{
　　}
2、还有一点很重要的事java中的main函数所在的类名必须和文件名相同。
　　其次是在一个文件中只能main函数所在的类是public修饰的，其他不能带public ，一个文件中只能有一个public类。
　　java中的静态成员既可以实例化对象调用，也可以类名来点出来，非静态成员只能实例化对象调用。****没有静态类

　　而在C#中静态成员不能实例化对象调用

3、java中方法的重写就方法的覆盖，貌似真的是覆盖，就是重新写一遍

　　而C#中的重写要用关键字override，并且只能是抽象和虚方法或者标记为override才能重写。

4、java中有一个特殊的static语句块功能，static语句块中的语句在构造函数之前执行且只执行一次

5、java和C#中初始化类的时候都是先初始化变量后执行函数代码

6、java中final的用法：
　　不想让类中的成员被子类修改
　　修饰类的时候，被修饰的类不能被继承
　　变量被final修饰的时候，必须赋初值
　　final和const类似（只是类似）
　　C#中不行让类被继承可以用关键字sealed修饰（密封）
　　不能让子类修改，不知道用什么方法

7、java中的集合
　　java中的ArraList集合跟C#中很相似，两者都是同样的声明方式。
　　一、List类型的集合
　　　　都是用的add方法（不同的事C#中的系统方法一般首字母大写）

　　有一个不同的地方是java中集合的取值方式用的事get("这里是对应的坐标")方法来取。而C#用的事跟数组一样的方法用下标取值:a[0]。
　　C#中的键值对集合有两种取值方法，一种是下标取值，一种是下标加键取值
　　java中获取集合中数量的方法是size(),而C#中用的是count()方法。
　　删除都是用的remove()方法，清空用的都是clear()方法。

　　LinkedList集合比ArrayList多了addFirst()和addLast()方法，分别指的是每次都添加在最前面或者最后面。（在有些需求的时候很有用）
　　vector和ArrayList的用法基本上一样
　　stack和ArrayList的用法也是基本上一样（但是值得注意的事stack因为栈的特点，所以每次插入新值的时候都是插在最前面的）
二、Map类型的集合（带有键值对的集合，类似于C#中的键值对集合）
　　主要有Hashmap，Hashtable等
　　添加键值对用put()方法。

　　读取方法：
　　//取出键的视图
　　Iterator<String > iterator=hashMap.keySet().iterator();
　　//遍历所有键
　　while (iterator.hasNext()) {
　　　　String string = (String) iterator.next();
　　　　((animal)hashMap.get(string)).sayhi();//读取并调用方法
　　}
三、总结
　　1、如果要求线程安全，应该使用Vector、Hashtable
　　2、如果不要求线程安全，应该使用ArrayList、LinkedList、HashMap
　　3、如果要求键值对，则使用HashMap，Hashtable
　　4、如果数据量很大，又要线程安全考虑Vector
　　Java中两个字符串比较值是否相等一定要用 s1.equals(s2)方法，不能直接用==来比较，这样比较的只是字符串的引用地址。

四、java中子类构造函数中调用父类的构造函数用super()；只能在子类的构造函数中写

　　而C#中直接在子类构造函数后面写:base()

　　例如：public son:father

　　{
　　　　son():base()
　　　　{
　　
　　　　}
　　}

五、swing主要布局方式
　　flowLayout（流式布局）、borderLayout（边界布局）、GridLayout（网格布局）等

六、java多线程
　　要使用多线程的类需要继承Thread，需要继承其他类的时候，要继承Runnable接口
　　继承Thread的时候，启用线程的方法：
　　类名（继承了Thread的） th=new 类名();
　　th.start()；
　　继承了Runnable接口的时候，启用线程的方法：
　　类名 l=new 类名();
　　Thread th=new Thread(l);
　　th.start();

　　thread.currentThread().getName();//用于显示当前是哪个线程在执行（显示的事线程的下标）
　　防止多线程并发的方法，加上synchronized(object){需要阻止并发的代码段}(如同C#中的Block锁)

　

　　七、java IO流

　　　　(1)字节流

　　　　　　　　

 public static void main(String[] args) throws IOException {
         File file=new File("e:\\wode.txt");//打开文件
         if(!file.exists()){
             try {
                 file.createNewFile();//创建文件
                 System.out.println("创建成功！");
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

         FileOutputStream fos=new FileOutputStream(file);//写操作
         String string="你好啊\r\n世界！";
         try {
             fos.write(string.getBytes());//写入数据
         } catch (IOException e) {
             e.printStackTrace();
         }finally{
             try {
                 fos.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }

         FileInputStream fis=new FileInputStream(file);//读操作
         int n=0;
         byte []bytes=new byte[4*1024];

             //fis.read(bytes, 0, (int) file.length());//按字节读取（一次读完）
             //String s=new String(bytes,0,(int) file.length());
             //System.out.println(s);

         while ((n= fis.read(bytes))!=-1) {//分块读取
             String s=new String(bytes,0,n);
             System.out.println(s);
         }
     }

　　　(2)字符流

　　　　　　　　

 public static void main(String[] args) {
         FileReader fReader=null;    //读操作
         FileWriter fileWriter=null;    //写操作
         try {
             fReader=new FileReader("e:\\wode.txt"); //直接读取路径
             fileWriter=new FileWriter("e:/我的.txt");
             int n=0;
             char[] c=new char[1024];
             while ((n=fReader.read(c))!=-1) {//循环读取，读到结尾返回-1（每次读取c的大小）
                 String s=new String(c,0,n);        //将字符数组转换成字符串
                 //System.out.println(c);
                 fileWriter.write(s);            //写入数据
                 System.out.println("写入成功");

             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 fReader.close();
                 fileWriter.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     }

　　　　

　　　----------------------------------
　　　　　按行读写文件（提高效率）

　　　　　　　　

 public static void main(String[] args) {
         BufferedReader bfr=null;
         BufferedWriter bfw=null;

         FileReader fileReader;
         try {
             fileReader = new FileReader("e:/wode.txt");            //读操作（作为 BufferedReader的构造参数）
             bfr=new BufferedReader(fileReader);        // 按行读操作
             FileWriter  fileWriter=new FileWriter("e:/我的.txt");    //写操作（作为BufferedWriter的构造参数）
             bfw=new BufferedWriter(fileWriter);        //按行写操作
             String string=null;
             while ((string=bfr.readLine())!=null) {    //循环读每一行，读到末尾返回null
                 System.out.println(string);
                 bfw.write(string+"\r\n");        //按行写
             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally{
             try {
                 bfr.close();
                 bfw.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }

         }

     }

　　

八、数据库
　　(1)开发时数据库的选择条件：
　　　　<1>成本
　　　　<2>功能多少
　　　　<3>并发性(最终用户多少)
　　　　<4>安全性

　　(2)基本查询
　　　　<1> sal between 100 and 200 //表示 sal>=100 and sal<=200
　　　　<2>like(模糊查询)
　　　　%:表示0到多个模糊字符 _；表示单个模糊字符
　　　　例如：1、查询姓李的人的名字
　　　　select name from emp where name like '李%';
　　2、查询名字的第二个字为明的人的名字
　　　　select name from emp where name like '_明%';
　　<3>查询条件是一个字段符合多个条件的时候，一般用in（批量查询）
　　　　例如：查询员工的年龄是22,25,31岁的员工的姓名
　　　　　　select name fron emp where age in(22,25,31);

　　<4>判断字段内容为null时返回指定的信息用isnull()函数
　　　　　　isnull(age,0); //这句话表示当age不为null时就返回实际的值，当为null时就返回0
　　<5>使用 Oder by 进行排序
　　　　order by age asc //默认升序
　　　　order by age desc //降序排列

　　　　例子：按照部门号升序，工资降序排列
　　　　　　select * from emp order by dempno asc ,sal desc;

　　<6> group by having
　　　　having 是用来筛选group by 分组后的数据
　　　　　　**在选择列中如果有列、表达式、分组函数，那么这些列和表达式必须有一个出现在group by子句中，否则就会出错！

　　<7>经典案例
　　　　　　--显示公司每个员工的名字和她的上级的名字
　　　　　　//这里可以把emp表看成两张表，分别是worker、boss
　　　　　　　　select worker.ename,boss.ename from emp worker,emp boss where worker.mgr=boss.empno

　　<8>分页查询
　　　　//这里的num1指的是每一页显示的行数，num2指的是第几页
　　　　　　select top num1 * from emp where empno not in (select top num1*num2 from emp);
　　<8>***疯狂在一个表中插入数据
　　　　　　insert into test(name,pass) select name,pass from test
　　　　insert into test select name,pass from test
　　<9>删除表中的重复记录
　　　　　　select distinct * into #temp from testTable
　　　　　　delete from tsetTable
　　　　　　insert into tsetTable select * from #temp
　　　　　　drop table #temp
　　　　　　<unique>唯一约束，不能重复，可以为null
　　　　　　<check>范围约束
　　　　　　<default>默认值
　　　　　　<foreign key>外键 用法：foreign key reference table2(id)

　　(3)备份、恢复数据库
　　　　　　备份：
　　　　　　　　backup database 要备份的数据库名字 to disk='路径';
　　　　　　恢复：
　　　　　　　　restore database 数据库名 from disk='路径'

九、JDBC

　　(1)演示使用JDBC-odbc桥接方式连接数据库cakesales
　　　　<1>配置数据源（在控制面板→管理工具→odbc配置工具里面）
　　　　<2>在程序中去连接数据源

*************1、使用Statement的方式*************************************
　　　　***代码如下****

　　　　　　　　　　　　

 Connection con=null;
                 Statement sm=null;
                 ResultSet rSet=null;
                 try {
                     // 1、加载驱动（作用是把需要的驱动程序加入内存）
                     Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
                     //2、得到连接
                     con=DriverManager.getConnection("jdbc:odbc:MySqlSever", "sa", "920606");

                     //3、创建Statement或者PreparedStatement[区别]
                     //Statement用处是：主要用于发送sql语句到数据库
                     sm=con.createStatement();

                     //4、执行crud（增删改查）

                     //增加
                     //int i=sm.executeUpdate("insert into cakecategory values('小蛋糕',1)");

                     //删除
                     //int i=sm.executeUpdate("delete from cakecategory where CGname='小蛋糕'");

                     //更新
                     //int i=sm.executeUpdate("update cakecategory set CGname='蛋糕'  where CGname='小蛋糕'");

                     //System.out.println(i);

                     //查询表信息
                     rSet=sm.executeQuery("select * from cakecategory");
                     while (rSet.next()) {
                         int id=rSet.getInt(1);
                         String name=rSet.getString(2);
                         int state=rSet.getInt(3);
                         System.out.println(id+"\t"+name+"\t"+state);
                     }

                 } catch (Exception e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }finally{
                     try {
                         if(rSet!=null)
                             rSet.close();
                         if(sm!=null)
                             sm.close();
                         if(con!=null)
                             con.close();
                     } catch (SQLException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }

*************1、使用PreparedStatement的方式*************************************

　　　　****此方法有以下有点
　　　　　　1>效率有所提高（因为对sql语句进行了预编译）
　　　　　　2>防止sql注入

　　　　***代码如下****

　　　　　　　　　　

 Connection connection=null;
                 PreparedStatement ps=null;
                 ResultSet rSet=null;

                 try {
                     //1、引入驱动
                     Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
                     //2、创建连接
                     connection=DriverManager.getConnection("jdbc:odbc:MySqlSever", "sa", "920606");
                     //3、创建PreparedStatement对象
                     ps=connection.prepareStatement("select * from cakecategory where CGname=?");
                     ps.setString(1, "蛋糕");

                     //4、获取结果集
                     rSet=ps.executeQuery();

                     //5、循环读取
                     while (rSet.next()) {
                         int id=rSet.getInt(1);
                         String name=rSet.getString(2);
                         int state=rSet.getInt(3);
                         System.out.println(id+"\t"+name+"\t"+state);
                     }
                 } catch (Exception e) {
                     // TODO: handle exception
                     e.printStackTrace();
                 }finally{
                     try {
                         if(rSet!=null)
                             rSet.close();
                         if(ps!=null)
                             ps.close();
                         if(connection!=null)
                             connection.close();
                     } catch (SQLException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                     }
                 }

(2)演示使用JDBC直接连接数据库cakesales
　　1>不用配置数据源，直接代码连接
　　2>此种方法需要引入外部的三个jar包，操作如下：
　　　　选中项目 右键-> 选择属性->选择java构建路径->选择 库 ->选择添加 然后导入三个驱动文件即可（msbase.jar 、 mssqlserver.jar 、 msutil.jar）
　　3>遇到几个典型的错误，如下
　　　　1)java.lang.ClassNotFoundException: com.microsoft.jdbc.sqlserver.SQLServerDriver
　　　　　　这个原因是因为没有打开sqlserver的监听端口导致的，解决方法如下：
　　　　　　　　*****选中计算机右键—>管理—>服务和应用程序—>sql server管理器—>sql server 网络配置—>MSSQLSERVER协议—>TCP/IP—>IP 地址 就可以看见了
　　　　2）java.sql.SQLException: [Microsoft][SQLServer 2000 Driver for JDBC][SQLServer]对象名 'cakecategory' 无效。
　　　　　　　　这是由于SQLSERVER帐号的默认数据库导致的。如果使用的库不是当前帐号的默认库的话，就会找不到表
　　　　　　　　解决方法：一、把帐号的默认数据库改为要查询的库
　　　　　　　　　　　　　　　　　　修改方法：打开数据库，在左侧菜单栏->安全性->登录名->sa 右键 属性 找到下面的默认数据库修改成要用的就行了
　　　　　　　　　　　　　二、在执行查询前先执行“use xxx”语句
　　　　　　　　*****推荐使用第二种解决方法！

*********************实例代码如下**********************************

　　　　　　　　　　　　　

 Connection con=null;
             PreparedStatement ps=null;
             ResultSet rSet=null;

             try {
                 //1、引入驱动
                 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
                 //2、创建连接
                 con=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;database=CakeSales","sa","920606");

                 //3、创建preparedStatement对象
                 ps=con.prepareStatement("use CakeSales select * from cakecategory");
                 //ps.setString(1, "蛋糕");

                 //4、接收结果集
                 rSet=ps.executeQuery();
                 //5、循环读取数据
                 while (rSet.next()) {
                     int id=rSet.getInt("CGid");
                     String name=rSet.getString(2);
                     int state=rSet.getInt(3);
                     System.out.println(id+"\t"+name+"\t"+state);
                 }
             } catch (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }finally{
                 try {
                     if(rSet!=null)
                         rSet.close();
                     if(ps!=null)
                         ps.close();
                     if(con!=null)
                         con.close();
                 } catch (SQLException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }

(3)演示使用JDBC直接连接数据库进行ddl操作（也就是新建，删除，备份，恢复数据库）

******************************实例代码如下******************************

　　　　　　　　　　　　

 Connection con=null;
             PreparedStatement ps=null;
             try {
                 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
                 //不指定数据库连接
                 //con=DriverManager.getConnection("jdbc:sqlserver://localhost:1433;", "sa", "920606");
                 con=DriverManager.getConnection("jdbc:sqlserver://localhost:1433;database=xinjiande", "sa", "920606");

                 //新建数据库
                 //ps=con.prepareStatement("create database xinjiande");

                 //新建表
                 //ps=con.prepareStatement("use xinjiande create table users(uid int primary key identity(1,1))");

                 //删除表
                 //ps=con.prepareStatement("use xinjiande drop table users");

                 //删除数据库
                 ps=con.prepareStatement("drop database xinjiande");

                 //备份数据库

                 //ps=con.prepareStatement("backup database xinjiande to disk='e:/xinjiande.bak'");

                 //恢复数据库
                 //ps=con.prepareStatement("restore database xinjiande from disk='e:/xinjiande.bak'");

                 if(!ps.execute()){
                     System.out.println("ok");
                 }
             } catch (Exception e) {
                 // TODO: handle exception
                 e.printStackTrace();
             }finally{
                 try {
                     if(ps!=null){
                         ps.close();
                     }
                     if(con!=null){
                         con.close();
                     }
                 } catch (SQLException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }

十、java中的可变参数
关键字：...（没错，就是三个点。好像C语言中也是三个点）
例子：下面是我下的连接数据库的可变参数

　　　　　　

 public sqlHelper(String sql,String ...strings){
             try {
                 this.sql=sql;
                 Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
                 con=DriverManager.getConnection("jdbc:sqlserver://127.0.0.1:1433;database=javaTset", "sa", "920606");
                 ps=con.prepareStatement(sql);
                 if(strings!=null){
                     int i=1;
                     for(String s:strings){
                         ps.setString(i, s);
                         i++;
                     }
                 }
             } catch (Exception e) {
                 // TODO: handle exception
                 e.printStackTrace();
             }
         }

****c#中的可变参数用的是parameter关键字

十一、java网络编程

和C#中的网络编程Socket差不多

1>服务器端代码及过程如下： 先建立ServerSocket监听->然后等待客户端连接->之后读取客户端发来的消息或者向客户端发送消息

　　　　　　

 try {
             //开始监听
             ServerSocket ss=new ServerSocket(9999);
             //等待客户端连接
             Socket socket=ss.accept();

             //读取客户端发来的消息
             BufferedReader bfr=new BufferedReader(new InputStreamReader(socket.getInputStream()));

             //向客户端发消息
             PrintWriter pWriter=new PrintWriter(socket.getOutputStream(),true);

             Scanner scanner=new Scanner(System.in);
             while (true) {

                 String string=bfr.readLine();//读取消息
                 System.out.println(string);

                 String s=scanner.next();//接收控制台输入
                 pWriter.println(s);//发送消息

             }

         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

　　2>客户端代码及过程如下：  先连接服务器->之后读取服务器发来的消息或者向服务器发送消息

　　　　　　

 try {
                 Socket socket=new Socket("127.0.0.1", 9999);//连接服务器

                 //发送消息
                 PrintWriter pWriter=new PrintWriter(socket.getOutputStream(),true);
                 //读取客户端发来的消息
                 BufferedReader bReader=new BufferedReader(new InputStreamReader(socket.getInputStream()));

                 Scanner scanner=new Scanner(System.in);
                 while (true) {
                     //发送消息
                     String s=scanner.next();
                     pWriter.println(s);

                     //读取消息
                     String string=bReader.readLine();
                     System.out.println(string);

                 }

             } catch (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

　　3>*****对象流传输例子如下，发送用的是ObjectOutputStream，接收用的是ObjectInputStream

*********************注意：对象必须要继承Serializable序列化接口***************************************

　　　　

 public class conSK {
             public static Socket sk;
             ObjectOutputStream oop;
             public conSK(){
                 System.out.println("gr");
                 try {
                     sk=new Socket("127.0.0.1", 9999);

                 } catch (Exception e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }

             /**
              * 向服务器发送数据
              * @param object
              */
             public  void sendMsg(Object object){
                 try {
                     oop=new ObjectOutputStream(sk.getOutputStream());
                     oop.writeObject(object);
                     //System.out.println(((User)object).getPwd());
                 } catch (IOException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             }

             /**
              * 接收服务器发过来的消息
              * @return 返回Object类型
              */
             public  Object getMsg(){
                 Object object =null;
                 try {
                     ObjectInputStream oop=new ObjectInputStream(sk.getInputStream());
                     object=oop.readObject();
                 } catch (Exception e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
                 return object;
             }
         }