Java学习笔记1-3

Java学习笔记1-3
阅读书籍:Java基础入门教程.pdf
章    节:第1-5章(共12章)
时    间:2014年5月1日张永辉
================================================================================
前  言：
    感谢写书的作者，这书写的挺好。主要是内容的安排上。循序渐进。
    可是此书未留名。《Java基础入门教程.pdf》499页，百度文库上找的。
第一部分：JAVA基础程序设计
第一章 认识JAVA
    1.1 Java的历史 Java 是 Sun 公司推出的新一代面向对象程序设计语言，特别适于 Internet 应用程序开发，他与平台无关。
    1.2 JAVA的现状
    1.3 JAVA的特点
          关键特性：
            1.简洁有效
            2.可移植性
            3.面向对象
            4.解释型
            5.适合分布式计算
            6.拥有较好的性能
            7.健壮、防患于未然
            8.具有多线程处理能力
            9.具有较高的安全性
            10.是一种动态语言
            11.是一种中性结构
    1.4 Java 虚拟机(JVM)： 使得“一次编写，处处运行”等待得以实现
        Java的架构包括以下三个方面
            J2EE (Java 2 Platform Enterprise Edition) 企业版
            J2SE (Java 2 Platform Stand Edition)      标准版
            J2ME (Java 2 Platform Micro Edition)      小型版
    1.5 JDK 的安装及环境变量的配置
        1 下载开发环境 jdk-6u27-windows-i586.exe 版本是1.6.27 即是Java Development Kit。
        2 双击安装
        3 在编译时要用Javac Java 这2个命令需要配置好环境变量，使得可以在任何目录下使用这两个命令。
            我的电脑击右->属性—>高级—>环境变量
            编辑 JAVA_HOME 值 D:\ProgramFiles\Java\jdk1.6.0_27
            系统变量 path后加 D:\ProgramFiles\Java\jdk1.6.0_27\bin;  环境变量即设置好了
    1.6 第一个JAVA程序
        1 在任意目录新建文件 cmd.bat 内容：c:\Windows\system32\cmd.exe    目的是开启命令窗口
        2 创建文件 Hello.java 内容如下
            public class Hello
            {
                //是程序的起点，所有程序由此开始运行
                public static void main(String args[])
                {
                    //此语句表示向屏幕上打印"Hello World !"字符串
                    System.out.println("Hello World !");
                }
            }
        3 双击 cmd.bat 执行以下命令
            javac hello.java        执行完毕会生成hello.class文件
            java  Hello             此句会输出 “Hello World !” 了， 大功告成！
    1.7 classpath
        假设使用开始->运行启动窗口，可以按以下进行执行程序
        set classpath=D:\ProgramFiles     它指定java类的执行路径 (hello.class所在路径)
        java  Hello                       此句执行成功
        注意； 一般的 set classpath=. 即当前目录。

第二章  简单JAVA程序
    2.1 示例程序 Test.java
        public class Test
        {
            public static void main(String args[])
            {
                int num ;       //  声明一个整型变量 num
                num = 3 ;       //  将整型变量赋值为 3
                                //  输出字符串，这里用"+"  号连接变量
                System.out.println("这是数字 "+num);
                System.out.println("我有 "+num+"  本书！");
                //System.out 是指标准输出，
                //println,是由 print 与line 所组成的.  使用System.out.print则不换行
            }   //{}形成一个程序段(segment)或是块(block)。
        }
        1 一个文件中只有一个public类，且与文件名相同。非public类可以有多个， 若无public类,文件可以随意命名。
        2 main() method 在一个 Java 程序中有且只能有一个 main()方法. 必须使用关键字public static void

    2.2 有以下关键字
         abstract   boolean     break       byte        case        catch
         char       class       continue    default     do          double
         else       extend      false       final       finally     float
         for        if          implement   import      instanceof  int
         interface  long        native      new         null        package
         private    protected   public      return      short       static
         synchronized super     this        throw       throws      transient
         true       try         void        volatile    while

第三章 JAVA基本程序设计
    3.1 变量与数据类型
        类型分类：         / 整数      byte:1   short:2   int:4   long:8
                          / 数值类型 - 浮点类型  float:4  double:8
                /基本类型 - 字符类型 char:2 (试验过了2字节)
               /          \ 布尔     boolean:1
        数据类型
               \          / 类       class
                \引用类型 - 接口     interface
                          \ 数组     []
        1 默认常数是int  ,long型要如此写才不会编译错误 long num = 900000000000L;
        2 最值的获取：
            long long_max   = java.lang.Long.MAX_VALUE ;        //得到长整型的最大值
            int   int_max   = java.lang.Integer.MAX_VALUE ;     //得到整型的最大值
            short short_max = Short.MAX_VALUE ;                 //得到短整型的最大值
            byte byte_max   = Byte.MAX_VALUE ;                  //得到Byte型的最大值
        3 最大值+1后变成最小值，即出现溢出了。
        4 字符型占2字节，JAVA使用Unicode码表示，可以按以下方式赋值：
            char ch1 = 97 ;
            char ch2 = 'a' ;
        5 浮点类型默认是double的，可以如下赋值
            float num = 3.0f ;
            double nn = 3.3;
            double mm = 1.7e10;
        6 最值
            java.lang.Float.MIN_VALUE
            java.lang.Double.MAX_VALUE
        7 bool 只能是true false
        8 自动类型转换，需要符合以下2条
            1 转换前的数据类型与转换后的类型兼容。
            2 转换后的数据类型的表示范围比转换前的类型大
        9 强制类型转换：在转换时会丢失精确度，此就必须要做强制性的转换。
            1 占用字节较少的类型转换成占用字节较多的类型。
            2 字符类型会转换成int类型。
            3 int 类型会转换成float 类型。
            4 表达式中若某个操作数的类型为 double，则另一个操作数字也会转换成 double类型。
            5 布尔类型不能转换成其它类型。
    2 表达式
        1 符号
            =   +   -   *   /   %   ！  ~(取补码)  ++ --
        2 关系运算符
            >   <   =   <=  >=  ==  !=  ?:
        3 逻辑  && ||
        4 优先级 使用()

    3 循环与选择语句
        1 一般来说程序的结构包含有下面三种：
            1 顺序结构
            2 选择结构
            3 循环结构
        2 if   if...else..   if..else if .. else if .. else
        3 switch (表达式)
            {
               case  xxx：xxx; break;
               ...
               [default：   xxx ;]
            }
        4 while(){}    do{}while()  [break continue]
        5 for(;;){}                 [break continue]

第4章 数字与方法
    4.1 一维数组
        int a[] ;        //  声明整型数组 score
        a = new int[4];  //  为整型数组 score 分配内存空间，其元素个数为 4
        或者写为：都行
            int a[] = new int[4];
            int[] a = {1,2,3,4};

       一维数组的方法
        1 score.length   可取得长度。
        2 Arrays.sort(a);        // 数组的排序方法：从小打大 ，库java.util。
    4.2 二维数组
    4.3 多维数组
        int a[][] ;
        a = new int[4][3] ;
        或
        int a[][] = new int[4][3] ;
        int[][] a = {{}{}{}};
       多维数组的方法
        a[n].length
        Arrays.sort(a[n])
    4.4 方法 (即函数)
        1 方法有 参数和返回值。
        2 方法可以重载：方法名相同，只要参数类型或个数不同即可。
        3 方法的参数是数组时,可以理解为指针。(因为在方法中可以改变原来的值)
        4 可以返回数组,返回在方法中new的数组,还可以使用(试验)(空间还没释放，与C不也一样)。

第二部分： 面向对象程序设
第5章 类的基本形式
    5.1 类 具有共同性质的事物的集合就称为类。
        1 组成：类名+成员变量(属性)+方法
        2 三个特征：
            1 封装  一是指把对象的属性和行为看成一个整体，二是指给变量及方法规定了不同级别的访问权限
            2 继承  派生类继承超类(父类)的所有成员，并增加新成员。
            3 多态  方法重载与成员覆盖两种形式的多态
        3 类与对象
            类是对某一类事物的抽象，对象是该类事物的个体,因而也称实例(Instance)
    5.2 类的声明及创建对象
        1 声明的格式如下
            class  类名称
            {
                [属性限定] 数据类型  属性;
                [方法限定] 返回值类型  方法名(参数)
                {
                    程序语句;               //定义方法的内容
                    return 表达式;
                }
            }
            eg
                class Person
                {
                    String name ;
                    int age ;
                    void talk()
                    {
                        System.out.println("我是+"name","+age+"岁");
                    }
                }
        2 创建对象
            Person p  ;                 //  声明
            p = new Person() ;          //  用new关键字实例化
            或者：
            Person p = new Person() ;   //  声明对象并直接实例化
                声  明： p在栈空间
                实例化： 在堆开辟空间存放p的内容，并将引用给声明p
    5.3 类的封装
        1 属性限定
            关键字      解释      用于          作用
            private     私有的    属性/方法     只能在其类的内部被调用， 否则编译错误
            public      共有的    属性/方法     外部可见
        2 get 与 set
            按标准通常使用setXxx()/getXxx()对private属性进行封装
            eg
                void setAge(int Age)
                {
                    age = Age;
                }
    5.4 在类内部调用方法
    5.5 引用数据类型的传递()
    5.6 匿名对象
        此对象没有名字，引用一次后被垃圾站回收
        eg
            System.out.println(new Person().talk());
    5.7 构造函数(方法)
        class Persion
        {
            static int year = 2014;
            public Persion()
            {
                System.out.println("1.Persion():"+year);
            }
            public Persion(String name)  //构造方法可以重载
            {
                //this只能放在构造方法的第一行
                this();   //此处调用了: Persion()
                System.out.println("2.Persion(string)");
            }
            void tallk()
            {
                //此处不能有this()
                System.out.println("no name");
            }
        }
    5.8 对象的比较
        有两种方式可用于对象间的比较，它们是“= =”运算符与 equals()方法，
            “==”操作符用于比较两个对象的内存地址值是否相等
            equals()方法用于比较两个对象的内容是否一致。
        eg
            String p1 = new String("Java");
            String p2 = new String("Java");
            String p3 = p1;
            if(p1 == p3)
            {   System.out.println("p1==p3");   }   //相等
            if(p1.equals(p2))
            {   System.out.println("p1==p2");   }}   //相等
    5.9 this 的作用
        this 表示当前对象
    5.10  static 的作用
        1 static 静态变量
        static 属性是所有对象共享的， 可以如下使用上面的例子
            static public Persion.year;
            Persion aa = new Persion("zyhui");
            Persion bb = new Persion("zyhui2");
            bb.year = 2015;     //aa.year 也被更改了
            //也可以如下更改,
            Persion.year = 2014;    //static变量 也叫做类变量
        扩展： 可以使用 static 来计数产生了多少个实例。 或者类之间的数据交换
        eg
            class Persion
            {
                int age;
                static int year = 2014;
                static int cnt = 0;
                static String cityy = "Chengdu";
                String name;
                Persion(String name)
                {
                    //1 使用静态 cnt 计数实例个数
                    System.out.println("number = " + cnt++);
                    this.name = name;
                }
                void tallk()
                {   //2 非静态方法可以引用静态变量。
                    System.out.println(name + " say: year is " + year);
                }
                static void city()
                {
                    //3 静态方法 只能引用静态变量 下面这句会报错(name是非静态的)。
                    //System.out.println(name + " say :i am at " + cityy);
                    System.out.println(         " this:i am at " + cityy);
                }
            }
        2 static 方法
            1 静态方法只能引用静态变量
            2 非静态方法可以引用静态变量
            eg 可以这样使用：
                Persion cc = new Persion("zyhui");
                cc.city();
                Persion.city();   //直接用类调用

        3 main 方法介绍
            1 public ：Java虚拟机需要调用类的main()，所以必须是public
            2 static : Java虚拟机执行main()时不创建对象，所以必须是static
            3 String : main接收一个String类型的数组参数
            eg
                public class Hello
                {
                    public static void main(String args[])
                    {
                        int i;
                        System.out.println("you args is :");
                        for(i = 0 ; i <args.length ;i++)
                        {
                            System.out.println(args[i]);
                        }
                    }
                    static
                    {
                        System.out.println("I am Static");
                    }
                }
                可以如此运行此程序： java Hello 12 34  结果如下
                I am Static
                you args is :
                12
                34
        4 static 静态代码块
            上例中的 static {} 是静态代码块
            特点：不包含在任何方法体中
            执行：类被载入时，静态代码被执行（先于构造函数），且只执行一次
            用途：经常用来进行类属性的初始化

    5.11 构造方法的私有
        1 private 方法 ( 相对于 public, JAVA默认是public)
            此方法只能在class内部被调用,外部不可用。
                private void tallk()
                {
                    System.out.println("my name is " + this.name);
                }
        2 构造方法的私有: 只能实例化一次的例子
            class Persion
            {
                int age;
                String name;
                //由内部实例化 这样就此CLASS就只能实例化一次了
                private static final Persion P1= new Persion();
                //被保护了，外部不能实例化
                private Persion()
                {
                    name = "zyhui";
                }
                public static Persion get_p()
                {
                    return P1;
                }
            }
            可以如下调用：
                Persion cc = null;      //也可以声明多个对象，但只得到同一个引用。
                cc = Persion.get_p();
                System.out.println(cc.name);
    5.12 对象数组
        方式1
            Person p[] ;                //声明 Person 类类型的数组变量
            p = new Person[3] ;         //用new分配内存空间
            p[0] = new Person () ;      //用new产生新的对象
            p[1] = new Person () ;
            p[2] = new Person () ;
        方式2
            Person p[] = new Person[3]; //创建对象数组元素，并分配内存空间
            for(int i=0;i<p.length;i++
            {
                p[i] = new Person() ;   //动态用new产生新的对象
            }
        方式3
            Person p[] = {new Person(),new Person(),new Person()} ;
    5.13 内部类
        1 格式如下
            标识符 class  外部类的名称
            {
                外部类的成员
                //内部类
                标识符 class  内部类的名称   //标识符 = public 或 private 与方法的作用同理。
                {
                    内部类的成员
                }
            }
        eg
            class Outer
            {
                int score = 95;
                void inst()
                {
                    Inner in = new Inner();
                    in.display();
                    //System.out.println("名字:" + name);  此句编译错误： 外部不能直接访问内部类的属性
                    System.out.println("名字:" + in.name);
                }
                //内部类默认是 public
                class Inner
                {
                    String name = "zyhui";
                    void display()
                    {
                        //内部类可以调用外部的属性:score
                        System.out.println("成绩: score = " + score);
                    }
                }
                //内部类
                static class Inner2
                {
                    String name2 = "zyhui2";
                    void display2()
                    {   //编译错误： static 类不能访问外部的非static成员 score。
                        //System.out.println("成绩: score = " + score);
                    }
                }
            }
            如此调用：
                //实例化外部类
                Outer oo = new Outer();
                oo.inst();
                //创建一个内部类实例
                Outer.Inner ii = oo.new Inner();   //不能这样： Outer.Inner ii = new  Outer.Inner();
                ii.display();
    5.14 注释（略）