java之旅之初识java

初识java

这是我第一次写博客，记录我正式踏入java编程，开始进入敲代码的日子。我希望以此博客来激励我，来督促我一定好好学习这门课程。经过半个多月的学习，从开始觉得枯燥乏味到现在觉得很有意思，很有学问，充满着很浓厚的兴趣。希望接下来的学习时间里会看到我的进步。欢迎大家给我提宝贵的建议，给我支持。

java基础

Java的发展历程如下
java一词是由他们在咖啡馆喝咖啡的时候灵机一动发现他们手中的咖啡杯上都写着“java”（爪哇岛产的咖啡）而来。java为何而来，java之James Gosling 吉祥物duke 是由java bean而来。最重要的常识是java是纯面向对象的高级编程语言。java现在的三个平台javaSE（桌面应用系统）、javaME（微型）、javaEE（企业级）。

java的技术特点

java的组成

• java虚拟机-JVM（Java Virtual Machine）
• java应用程序编程接口-java API（Application Programming
  Interface）

java的特征

1. 简单的
2. 结构中立
3. 分布式
4. 可移植性-跨平台（Windows，Linux，Unix，Mac）
5. 高性能
6. 健壮性（卤棒性）-不容易崩溃
7. 动态
8. 安全性-GC-垃圾回收机制

java的基础语法

一. 关键字
　　1、定义和特点
　　定义：被Java语言赋予了特殊含义的单词。
　　特点：关键字中所有的字母都为小写。
　　2、分类
　　（1）用于定义数据类型的关键字：byte、short、int、long、float、double、char、boolean、class、interface、void
　　（2）用于定义数据类型值的关键字：true、false、null
　　（3）用于定义流程控制的关键字：if、else、switch、case、default、for、while、do、continue、break、return
　　（4）用于定义访问权限修饰符的关键字：private、protected、public
　　（5）用于定义类、函数，变量修饰符的关键字：abstract、final、static、synchronized
　　（6）用于定义类与类之间关系的关键字：extends、implements
　　（7）用于定义建立实例及引用实例，判断实例的关键字： new、this、super、instanceof
　　（8）用于异常处理的关键字：try、catch、finally、throw、throws
　　（9）用于包的关键字：package、import
　　（10）其他修饰关键字：native、strictfp(strict float point，精确浮点)、transient(变量修饰符，用它声明一个实例变量，在对象序列化时不会被序列化)、volatile(类型修饰符，用来修饰被不同线程访问和修改的变量) 、assert(断言，可以看作是异常处理的一种高级形式，用于捕捉我们在代码中做出的假设)
注意：main不是关键字，却是被虚拟机所识别的一个名称。

二、常量
　　1、定义：java中不能改变的数值，在程序中只能被引用，而不能被重新赋值。
　　2、分类：
　　（1）整数常量。所有整数。int型。
　　（2）小数常量。所有小数。float，double。
　　（3）布尔型常量。较为特有，只有两个数值。true false。
　　（4）字符常量。将一个数字字母或者符号用单引号( ’ ’ )标识。
　　（5）字符串常量。将一个或者多个字符用双引号(“”)标识。
　　 注意： String s = null;空，里面没有东西。
　　 String s = “”; 空字符串，有东西，但内容为空。
　　 两者是不一样的概念。
　　（6）null常量。只有一个数值就是：null。
　　3、对于整数，Java有四种表现形式：
　　（1）二进制（Binary）：0，1，满2进1
　　（2）八进制（octal）：0-7，满8进1，用0开头表示。
　　（3）十进制（decimal）：0-9，满10进1。
　　（4）十六进制（hexadecimal）：0-9，A-F，满16进1，用0x开头表示。
三、变量
　　1、定义：内存中的一个存储空间，该空间有自己的名称（变量名）和类型（数据类型）。
　　2、作用：用来不断的存放同一类型的常量，并可以重复使用。
　　3、定义的格式：数据类型 变量名 = 初始化值。例如：int x = 5;
　　4、变量作用范围：从变量定义开始到定义它的代码块结束。同一范围内，不允许多个局部变量命名冲突。　　
　　5、Java有两种数据类型：基本数据类型、引用数据类型，结构图如下：

　　6、Java基本数据类型：所占字节数及取值范围，如下图：
　　

　　7、“自动类型提升”和“强制类型转换”
　　（1）自动类型提升：
　　在运算中，所有byte型、short型和char型将被提升到int型。
　 整个算术表达式的数据类型自动提升到与表达式中最高等级
操作数同样的类型。类型提升示意图如下：
　　（2）强制类型转换：当程序中，数据类型需要变换时，可以进行强制转换。
　　8、面试小细节
　　若 byte b = 4;byte b1 = 3; b3 = 7;
　　则：b = b1+b2;//运行出现“可能溢出”，因为b1、b2是变量，无法判断结果是否溢出。
　　而：b = 3+7 则可以通过运行
　　经典面试题：

public static void main(String[] args) {
        int a = 1 ;
        System.out.print(true ?'b': 65535);
        System.out.print(true ? 'b' :100000);
        System.out.print(false ? a: 'b');
    }

运行结果：b，98,98
四、运算符
　　运算符是一种特殊符号，用以表示数据的运算、赋值和比较等，共分以下几种：
　　（1）算术运算符
单目运算符：+（取正）、－（取负）、++（自增1）、–（自减1）。
双目运算符：（＋ 、－、* 、／、%）­
其中 % 如： 8%5=3；8%-5=3；-8%5=-3；-8%-5=-3；模的正负只有被除数有关，与除数无关；且参与的两个数必须是整数。
三元运算符：a>b? val1： val2。 说明：当a大于b为true时，返回val1的值，否则返回val2的值
　　（2）赋值运算符（= 、+=、－=、*=、/=，、%=）;右边的结果赋值给左边的变量，左边只能是一个变量。由操作符与操作式组成的。
　　（3）关系运算符（==、!=、>、>=、<、<=、instanceof（判断是否是某一个类的对象））
　　（4）逻辑运算符（&&、||、！&、|、^）
　　其中，&和&&的特点是：单&时，左边无论真假，右边都进行运算；双&时，如果左边为真，右边参与运算；如果左边为假，则右边不参与运算。
而“|”和“||”的特点是：“|”表示其两边都参与运算。而“||”时，表示当左边为真，右边不参与运算。
（5）位运算符（&、|、^、~、>>、<<、<<<、>>>）
　 左移（<<）：空位补0，被移除的高位丢弃，空位补0。
　 右移（>>）：被移位的二进制最高位是0，右移后，空位补0；最高位是1，空位补1。
　
　无符号左移动和右移（<<<、>>>）：被移位二进制最高位无论是0或者是1，空缺位都用0补。
　与（&）：二进制位进行&运算，只有1&1时结果是1，否则是0。
　或（|）：二进制位进行 |运算，只有0 | 0时结果是0，否则是1。
　异或（^）：任何相同二进制位进行^运算，结果是0。注意：一个数异或同一个数两次，结果还是这个数。一个数异或本身等于0，一个数异或0等于本身。
　a^a==0;a^0==a;
　华为面试经典案例：a b 值互换。
　

public class test1 {
    public static void main(String[] args) {
        int a = 10;
        int b = 6;
        a = a ^ b;
        b = a ^ b;
        a = b ^ a;
        System.out.println("a = " + a);
        System.out.println("b = " + b);

    }

五、程序流程控制
　　1、程序流程分类
　　四种类型：顺序结构、分支结构（条件结构）、循环结构、控制循环结构
　　2、四种流程控制定义及特点
　　（1）顺序结构：代码里没有流程控制，程序是至上而下顺序地执行完成的，即一条语句执行完之后继续执行下一条语句，直到程序的最后。
　　（2）分支结构：常见的分支结构包括if…else…语句及swtich语句
　　① if…else…语句
　　基本语法：if(表达式){方法体}else if(表达式){方法体}else(方法体)
　　三种格式：
　　if(条件表达式){执行语句;}
　　if(条件表达式){执行语句;}else{执行语句;}
　　if(条件表达式){执行语句;}else if (条件表达式){执行语句;}……else{执行语句;}
　　② switch控制语句
　　定义格式：
　　switch(表达式)
　　{ case 表达式结果值1：
执行语句；
　　　　　　　　break；
case 表达式结果值2：
执行语句；
break
default：
执行语句；
　　}
　　switch语句特点：
switch语句选择的类型只有四种：byte，short，int， char。
case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
结束switch语句的两种情况：1、遇到break结束；2、执行到switch结尾结束。
如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
switch语句妙用：
如：输入一个年月日，请算出这一天是这一年的第多少天？

        Scanner scan = new Scanner(System.in);
        System.out.println("请输入年：");
        int year = scan.nextInt();
        System.out.println("请输入月：");
        int month = scan.nextInt();;
        System.out.println("请输入日：");
        int date = scan.nextInt();

        int result = 0;//存放最終結果
        switch(month){
        case 12:
            result += 30;
        case 11:
            result += 31;
        case 10:
            result += 30;
        case 9:
            result += 31;
        case 8:
            result += 31;
        case 7:
            result += 30;
        case 6:
            result += 31;
        case 5:
            result += 30;
        case 4:
            result += 31;
        case 3:
            result += 28;
        case 2:
            result += 31;
        case 1:
            result += date;
        }

        if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)){
            if(month > 2){
                result += 1;
            }
        }
    System.out.println("这是这一年的第" + result + "天");

　　注：JDK1.5以后可以接收枚举类型，JDK1.7以后可以接收字符串。
　　if和switch语句很像。具体什么场景下，应用哪个语句呢？如果判断的具体数值不多，而且符合byte short int char这四种类型。虽然两个语句都可以使用，建议使用switch语句，因为效率稍高。其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。
（3）循环结构
做循环找规律，除了找数字规律以外，可以找业务流程规律。
业务变化的过程也是规律。
　　While：事先不需要知道循环执行多少次；当某个条件不满足时，退出循环。
　　do while：同上，只是至少要执行一次(先执行，后判断)；
　　for：需要知道循环次数；可控制步长。
　　递归 还有一种用的不是很多但是有一些情况会用到，叫递归。递归就是让一个方法自己调用自己，就形成了递归。即同一种行为且后一次计算使用的是前一次的结果。例如：
　　递归的巧妙使用：
　　计算十进制数转换为二进制数：
　　代码如下：

import java.util.Scanner;

    public class tenToTwo{
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入要转二进制的数：");
            int num = sc.nextInt();
            tenToTwo(num);
    }
        public static void tenToTwo(int num){
            int mod = num % 2;
            int result = num / 2;
          if(result > 0){
              tenToTwo(result);
           }
          System.out.print(mod+" ");
        }
//      public static void tenToTwo(int num){
//          if(num > 0){
//              tenToTwo(num / 2);
//              System.out.println(num % 2);
//          }
//      }

　　
　　while循环，定义格式如下：
　　while(循环条件语句)
　　{ 循环体； }
　　do while循环，定义格式如下：
　　do
　　{ 循环体； }while(循环条件语句)

　　for循环，定义格式如下：
　　for(初始化表达式；循环条件表达式；循环后的操作表达式)
　　{ 循环体； }
　　补充：JDK5.0后的增强型for循环，定义格式如下
　　For（变量类型 变量名 ： 变量名集合）{ 执行语句； }
　　（4）嵌套循环及控制语句
　　嵌套循环：循环里套循环，即外循环嵌套内循环，其中外循环“控制行”，内循环“控制列”，假设外循环的循环次数是m次，内循环的循环次数是n次，那么内层循环的循环次数需要 m * n次。代码示例如下（打印九九乘法表）：

 for（int x = 1；x<=9；x++）{       
  for(int y = 1；y<=x；y++){               System.out.print(x+”*”+y+”=”+x*y+”\t”);4   
}     
         System.out.println(); 
}

　　控制语句：包括break语句、continue语句；
　　break：终止该层循环；
　　continue：结束本次循环，进入下次循环
　　注：
　　① 若这两个语句离开应用范围，存在是没有意义的。
　　② 这个两个语句后面都不能有语句，因为执行不到。
　　③ continue语句是跳过本次循环，继续下次循环。
　　④ 标签的出现，可以让这两个语句作用于指定的循环，通常不建议使用。
　　
六、方法
　　1、定义：方法是具有一定功能的小程序段。
　　2、定义格式：
　　修饰符 返回值类型 方法名(参数列表){
　　执行语句；
　　return 返回值；
　　}
　　3、特点：功能代码的封装，进行复用；调用才能执行。
　　4、注意事项：① 当方法执行后无返回值，此时返回值的数据类型用void作为返回值类型，此时return语句可以省略不写。② 方法之间是平行关系，只能相互调用，不能在方法内定义方法。③ 方法存放在类中。
　　5、如何定义方法？
　　定义方法要有两个明确：① 方法的运算结构式什么。② 明确该方法是否需要有参数参与运算，参与运算的参数类型和个数的情况如何。
　　6、方法重载（@override）
　　* 方法重载：是指在“同一个类”中，参数名称相同，而参数的类型和个数不同。又称“同名方法，重复载入”。
　　* “方法重载”与“方法返回值类型”无关。方法重载代码示例：

 public class overrideDemo  {        
  public static void main(String[] args) {
int sum1=add(3，4); 
       int sum2=add(3，4，5);              
       System.out.println(sum1);                
       System.out.println(sum2); 
   }     
      public static int add(int a， int b) {    
           int sum = a+b;      
               return sum;
      }
         public static int add(int a , int b, int c){               int sum;18         
         return sum;    
    }
 }

七、数组(Array)
　　（一）定义、内存空间划分、Stack、Heap、数组常见异常问题
　　1、定义：数组是Java 语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，目的是用来一次存储多个数据。数组中每个元素必须是相同的数据类型。
　　2、内存空间划分、Stack、Heap、数组常见异常问题：
　　内存空间划分：寄存器、本地方法区、方法区（代码段）、栈内存、堆内存。
　　数据段：存储字符串，常量
　　栈内存：存储局部变量，作用域结束后释放（垃圾回收机制）。
　 堆内存：存储数组/对象，凡是new出来的数组或对象都建立在堆中。其中，每一个对象实体都有一个首地址；每一个变量都有默认初始值。其中属性—会被自动初始化、基本数据类型为0，引用数据类型为null
　　数组常见异常问题：ArrayIndexOutOfBoundsException、NullPointerException
　　（二）一维数组
　　1、格式
　　格式1：元素类型[] 数组名 = new 元素类型[元素的个数或数组长度];
　　　　　　示例：int[] arr = new int[5]；
　　格式2：元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
　　　　　　示例：int[] arr = new int[]{3,5,1,7}; int[] arr = {3,5,7,1}；
　　2、数组常见操作
　　（1）数组遍历，代码如下：

 int arr[] = {12，23，34，12，45};
  for（int x=0; x<arr.length; x++）{
         System.out.println(arr[x]);
  }

　　（2）求最值，代码如下：

   int arr[] = new int[] { 23,26,45,13,12,56,87 };               int max = arr[0];
  for (int i = 0; i < arr.length; i++) {
      max = arr[i];
    }
    }
                       System.out.println(max);

　　（3）数组排序：
　　* 选择排序，代码如下：

 public static void selectSort(int[] arr){ 
         for( int x=0;x<arr.length-1;x++){ 
           for(int y = x+1;y<arr.length; y++){           
               if( arr[x] > arr[y] ){ 
                  int temp = arr[x];                              
                   arr[x] = arr[y];                   
                   arr[y] = temp;             

    } 
  }
     }
   }

　　* 冒泡排序，代码如下：

  public static void BubbleSort(int[] arr){ 
         for( int x=0;x<arr.length-1;x++){      
                 for(int y = 0;y<arr.length-1-x; y++){   
                  if( arr[y] < arr[y+1] ){             
                      int temp = arr[y];      
                      arr[y] = arr[y+1]; 7                            
                       arr[y+1] = temp;           
   }             
  }      
  }
  }
　

(4)查找

 public static void getIndex(int[] arr , int key){        for( int x=0 ; x<arr.length-1 ; x++){             
  if( arr[x] == key)                   
    return x;5        }
       Return -1;7 }

　　（三）二维数组
　　1、定义：其实是一个一维数组，它的每一个元素又是一个一维数组。
　　格式1：int[ ][ ] arr = new int[3][2];　　　　定义了一个二维数组，其中有3个一维数组，每一个一维数组中有2个元素
　　格式2：静态初始化：int[ ][ ] arr = new int[][]{{4,8}，{3,7}，{9,16}};
　　　　　　　　　　　　int[ ][ ] arr = {{1,2}，{3,4}，{5,6}};
　　2、应用示例：

 public class Demo3 {   
      public static void main(String[] args) {       
           int age[][] = new int[][]{{1,2},{3,4},{5,6}};              System.out.println(age[0][0]);             //输出结果：15               System.out.println(age[2].length);        //输出结果：26        }
}

八、引用数据类型数组（对象数组）