JAVA

一章 JAVA简介
一. 认识JAVA
1. SUM公司开发,非微软
2. 原名:Oak
3. java 之父:James Gosing
4. Internet 救了JAVA,JAVA 成就了Internet
二. JAVA 的3 个版本
1. j2se 标准版本  桌面应用程序
2. j2ee 企业版    服务器,客户端
3. jeme 微型版    原始,手机开发
三. 2 种程序类型
1. Appleet 小应用程序
2. 应用程序
四. 开发环境
1.JDK: JAVA 开发工具包,版本 1.4 或1.5
工具包目录:
bin :命令文件                                lib:类库文件
demo:演示程序                               jre:运行环境
3. 配置环境变量
(1).右击我的电脑-->属性-->高级-->环境变量
配置: Path: java 完整路径/bin ; 注:路径与路径用分号隔开
(2).classpath: java路径/lib;.; 注:点表示当前文件夹
(3).开发过程
a.编码,记事本
  例:
  class 类名
  {
   public static void main(String args[])
   {
    System.out.println("输出内容");
   }
  }
  注:String, System 第一个字母大写
     类名与文件名相同,区分大小写
     源文件点后缀.java
b.运行-->Cmd-->文件存放位置       CD命令 进入
  编译格式: Javac 文件名.java
  运行格式: Java 文件名
  注:编译时,文件名一定要带后缀.Java ,在编译后产生.Class字节码文件.
     System.out.println()     println  换行,print  不换行
     +:能相加则相加,不能则相连
   例:
   a=10;
   System.out.println("a="+a);
   结果:a=10;
(4).虚拟机:JVM 负责解释字节码,
    JVM 实现了跨平台,但本身不跨平台,
    java 解释运行:源文件.java--javac 编译-->字节码.class--jvm解释-->机器码
    C    编译运行:源文件--编译-->目标C机器码
    注释:/**  */文档注释,通过java doc 指令生成帮助
   
二章.JAVA 语言基础

一.数据类型
                                      byte    1字节,数据传输
                                      char    2字节,带单引号,可存放汉字
                           整型       short
                                      int
                                      long
                    数字                 
                                      float    1.5F  float 中的F不能省略,否则为double类型
                           小数
  基本数据类型                       double   1.5L  L 可省略

                   布尔型:boolean,   true(真) / false(假)
                  
二.引用数据类型
    1.数组
    2.类
    3.接口
  注:1.大小:由大到小:  double-->float-->long-->int-->short/char-->byte 
     2.结果类型为大类型:
        例:(1)
        int a=10,float b=1.5f,c=a+b;     
        结果  c 为 float 类型
        例:(2)
        3>4?9.9:5
        结果为 5.0,取大类型  double
     3.小类型到大类型自动转换,大类型到小类型必须强制转换
       例:(3)
       int a=(int)1.5;
       1.5为double 类型,将double 类型转换为int 类型
     4.数字不能转布尔,布尔不能转数字
     5.整数在运算时都提升为int 类型,即结果至少是int 类型
       例:(4)
       byte a=1;
       byte b=2;
       byte c=a+b;    报错,因为a,b 在运算时提升为int 类型
     改:int c=a+b;  或 byte c=(byte)(a+b);
  
三.变量
   1.先声明再使用,命名:可包含字母,数字,符号,但不能使用数字开头,可使用 $Aa_作为开头   A_123;
   2.变量的作用域,包含他的代码块   {}
   3.运算符
     a.&& 短路与,如果前面为假,直接为假,不再运算
       &  与,   全部运算, 两个条件为真,结果为真
      例:(5)
      int a=0;
      if (3>4& ++a==2)   结果为:假  a=1;
      if (3>4&& ++a==2)  结果为:假  a=0;
     b.|| 短路或, 如果前面为真,结果为真,不再运算
       |  或,    全部运算,只要一个条件为真,结果为真
     c.^ 异或,  不同不真,相同为假
     d.if(表达式) 表达式必须为布尔型,
       swith(表达式) 表达式必须为非长整数,每个case 都必须加break,否则一直往下执行,default位置可任意,但执行顺序
       先case后default
       嵌套循环:大循环一次,小循环一轮,
      例:(6)
      for (int i=1;i<5;i++){}
      1到4循环,跳出循环时i 为5
     
四.数组
            类型 数组名   申请空间 空间类型  空间大小             引   用     对     象
    1.声明: int    a[]  =    new      int    [5];                double b[]=new double[10];
      通过引用(名)找到对象,    数组分类: 引用 和 对象 两类
     注:第一个[]不能加空间大小(数字),第二个[]长度可为变量
    例:(7)
    int a[] =new int [10];
    int b[]={1,2,3};  b[]中不能加长度,可在声明数组时赋值
    int c[]=new int [3]{1,2,3};  错误,在声明赋值时[]中不能规定空间大小  [3]
    int d[]; d={1,2,3}  报错  数组只有在初始化集体赋值,否则只能单个赋值
    先产生引用,再指向对象
    int e[]=new int [3];
    int f[]={1,2,3,4};
    a=b;
    可以,只是引用的转移,a抛弃原用的3块空间,与b 共同指向后4块空间,后4块空间有2个名
   2.命令行参数
     java 文件名  参数1 参数2,参数n,
     注:a.参数之间用空格隔开,
        b.命令行参数会自动存入args[]数组中,
        c.下标从0开始,
        d.参数为 String 型字符串
        e.字符串转int 类型
        例:(8)
        int a=Integer.parseInt(args[0]);
        字符串转float 类型
        float b=Float.parseFloat(args[1]);
        f.如果提供参数不够,报错
       
       
三章.面向对象的概念和java实现
  
 一.OOP:Object Oriented Programming 面向对象编程
  面向过程:为解决问题而采用的步骤
  面向对象:制造对象,解决不类问题
  类制造者:制造对象
  类使用者:掌握尽可能多的类
  类:  一类对象的总称,描述对象,制造对象
  对象: 一切皆为对象
  属性:特征,状态(变量)
  方法:行为,功能(函数)
  抽象:关注重要属性为方法,忽略次要(提取)
  消息传递:对象之间通讯
  封装:隐藏属性和方法,及实现过程
 
  1,代码
    Class 类名
    {
     类型  变量名;  //用变量表属性
     返回类型   函数名(参数)
      {
       功能;    //用函数表示方法
      }
    }   
   
 2.实例化对象
   a.类名 对象名=new 类名();
   b.类名 对象名;
     对象名=new 类名();
     Teacher t =new Teacher();   //Teacher 为类名  产生一个老师类型的对象名为t
          new 为对象在堆中开辟空间
          Teacher() 构造函数,制造对象
          Teacher t;声明一个引用指向对象,相当于对象名
       
 3.属性,方法
    对象名.属性名            对象名.方法名()
    注:类中只能包含属性和方法,涌有其它代码(即代码必须放在方法中)
   
 4.变量
    成员变量(属性) 有默认值,数字为 0,布尔型为flase, 对象为null
    方法中的变量:无默认值,未赋值直接使用报错
    构造方法:制造对象(初始化对象)与类同名
    分类:
        (1).默认构造函数
        (2).显示构造函数
           a.无参构造函数
           b.有参构造函数
    格式:
        类名(类型1,参数1.....)
      注:a.构造方法与类同名,无返回类型         
         b.可以有多个构造方法,但参数的类型和个数不一样,系统会根据参数调用不同的构造方法
         c.构造方法必须写在new 后面
         d.如果不写显示构造方法,系统调用默认构造方法,如果有显示构造方法,默认构造方法自动消失
        
 二.包:文件夹
    作用:
        1.保护类,属性和方法
        2.层次分明,便于管理类
        3.避免命名冲突
    操作步骤:
        1.建立包    package 包名,习惯小写
            注:package 必须位于第一行,不能有两个package
        2.编译时为包指定位置
            javac -d 位置   类名.java
          例:
          javac -d c:/ Teacher.java
          javac -d . student.java  点代表当前文件夹
        3.跨包调用
          import 包名.类名
            注:
               a.可以有多个import
               b.也可以不写import,使用时直接 包名.类名
               c.被调用的类,方法,属性必须为public,参数可以是对象,如果改变对象的属性是有效的(影响原值)
                 如果改变对象的引用是无效的(不影响原值)
            例:
            Class Yufu
            {
              String zt="脏了";
            }             
            Class Demo
            {
             public static void main(String args[])
              {
               Yifu yf=new Yifu();
               Gxd  g=new Gxd();
               g.xi(yf);     //让干洗店洗衣服
              }
            }
            Class Gxd
            {
             void xi (Yifu y)
             {
              y.zt="干净了";   //y 和 yf是指同一件衣服,所以yf.zt由脏变成干净
              y=new Yifu();
              y.zt="干净了";   //因为不是同一件衣服,所以yf.zt还是脏的
             }
            }
           
           
 四章.面向对象的概念和java实现(2)
 
 一.面向对象的三大特征
    封装:隐藏细节
    继承:子类重用父类的代码
    多态:方法的同名不同用
    继承只能是单一的,即一个子类只能有一个父类,一个父类可以有多个子类
   
    继承:层次/重用
    语法:
       Class 子类 extends 父类
     注:
        a.子类可以重用父类的属性和方法
        b.父子关系是相对的
        c.构造子类对象时会先调用父类的构造方法再调用子类的构造方法
        d.只能自动调用父类无参构造方法,如父类无无参构造方法报错
   
    super: 手动调用父类构造方法/调用父类普通方法
    语法:
       1.调用父类构造  super(参数)        注:必须位于子类构造方法的第一行
       2.调变通方法    super.方法名()     注:无位置要求
     
二.多态
   1.重载:在同一类中,方法名相同,参数个数,类型或顺序不同     注:与返回值参数名无关
   2.重写:在子类中重写父类的某个方法
     作用:改写父类和改善欠类方法   
     注:
     a.重写时,方法名和参数必须完全一样
     b.不能缩小访问范围
     c.不能扩大异常的范围
    
三.final :终级类
   final 类:是不能被继承
   final 方法:不能在子类中重写
   final 属性:常量,不能改变
  
四.static :静态(全局)
   1.方法:类名.方法名()
   2.属性:类名.属性名
   3.代码块:
     a.先加载静态属性,方法,再有对象
     b.静态方法中只能使用静态属性
     c.静态方法中不能使用this 和 super关键字
    
五.abstract :抽象
   1.抽象类:不能实例化,即不能产生对象,只能被继承
   2.抽象方法:只能方法的声明没有方法体
      语法:
           abstract 返回类型  方法名(参数)
        注:
          a.子类必须实现父类的所有抽象方法除非子类出变成抽象类
          b.有抽象方法的类必须为抽象类,抽象类中不不一定要有抽象方法
         
六.接口: 多重继承,描述业务规则
   定义:interface 接口
       注:
          a.接口中的所有方法都是抽象方法且公有,自动加public,abstract
          b.接口中的属性都是public ,static ,final 即常量,子类实现接口
          c.接口不能产生对象
    语法:
        Class 类名 implements 接口名1,接口名2
        注:
           a.子类必须实现接口中的所有方法
           b.所有方法都必须加public
           c.子类实现接口,子类继承父类
           d.类对类用extends, 类对接口用 implements, 接口对接口用extends
          
七.修饰符
   private   私有                protected  受保护                   default  缺省            public  公有
  
   只读属性
   private String name;   //将属性变为私有
   String getName();
   {
    return name;   //只读
   }
  
   只写属性
   private String PassWord;
   void setpassword(String pwd)
   {
    PassWord=pwd;    //为该属性配写方法
   }
  
  
五章.异常
  一.错误:
      1.语法错误(编译时出错)
      2.运行时出错(异常)
      3.逻辑错误
     
  二.异常关键字
      try,    catch     finally       throw     throws
     
   如果出现异常未处理,程序中止
   try,catch格式:
    try
    {
     可能出现异常的代码(监视代码)
    }
    catch(异常类,引用)
    {
     处理代码
    }
    注:
       1.一个try可以有多个catch,只执行一个catch,即处理一次
       2.父类可以捕获子类的异常,所以父类必须位于子类之后
       3.异常处理可嵌套,先内后外
       4.常用的处理错误的两种方法
         tx.printStackTrace();     //显示异常的详细信息
         System.out.println(ex.toString());    //显示异常
   finally 强制要求某段代码必须执行除 System.exit(0)
     注:
        try,catch,finally 不能单独出现,不能只出现catch 和 finally
        thorws 抛出异常,谁调用谁处理
        thorw 引发异常,格式: void 方法名() thorws 异常
   自定义异常
   class Fushuexception extends RuntimeException
   {
    public String toString();   //重写toSting 方法
    {
     return ("不能是负数");
    }
   }
   Class yanzheng     //产生异常
   {
    static void yz(int a)
    {
     throw new FushuException ();
    }
   }
   Class Demo    //测试,捕获异常对象
   {
    public static vodi main (String args[])
    {
     int i=Integer.ParseInt(args[0]);
     try
     {
      yanzheng.yz(i);    // 产生对象异常
     }catch (FushuExcetion e)    //捕获
     {
      System.out.println(ex.toString());      //调用异常的toSting方法
     }
    }
   }
  
  
六章.JAVA.lang 包
     前提:java.lang  自动导入(即可写可不写)
  一.包装类
    1.作用:将原始数据类型包装成对象进行操作,得到相应属性和方法
    2.八种基本数据类型的包装类名为将首字母大写,但int 为Integer,char 为characher
    3.产生对象
      a. Integer 对象名=new Integer(20);
        Integer 对象名=new Integer("100");
      b.Integer 对象名=Integer.valueof(20);
    4.变通方法
      a.将字符串转换为数字
         Integer.parseInt("20");
         Float.parseFloat("20.5");    //类名.方法名()
    
      b.将数字转换为字符串
         String.valueof(10)
  
   二.String 是类,不是基本数据类型
     1.作用: 产生字符串,并提供方法对字符串进行操作
     2.产生字符串
       a.直接产生,指向字符串池,String str="java";
       b.利用构造方法指向堆空间
          String str=new String ("java");
          char c[]={'j','a','v','a'};
          String str2=new String(c);
     3.字符串池:如果池中已存在现成的相同的字符串不再产生新的,直接使用,节约空间
       堆空间:不管是否存在,都产生新字符串,可回收
     4.字符串比较
        equals()  比较字符串的字面是否相同
        ==  比较字符串是否指向同一对象
     5.常用方法
       a.length() 长度,     注:数组中length 为属性
       b.charat(位置) 查看某位置上的字符
       c.indexof('字符')  查看某字符的位置,没找到位置为-1
       d.substring(开始位置,结束位置)   截取字符串
      
    三.StringBuffer 可变字符串,但String 不可变
       1.构造对象
          StringBuffer sb=new StringBuffer("字符串");
       2.常用方法
          append() 追加                            delete()  删除
          insert() 插入                            reverse() 反转
   
    四.Math 数学类,包含数学计算的方法
       所有方法都是静态方法,  类名.方法名()
      
    五.oBject类,是所有对象的父类(根类)
       toString()  转换成字符串
      
    六.Class 类,用于检索类的信息
   
   
七章.java.util 包  显示导入