第一部分：Java语言的基础组成

Java语言的基础组成：

1、关键字 2、标识符 3、注释 4、常量和变量 5、运算符 6、语句 7、函数 8、数组

1、关键字 java中被赋予特殊含义的单词，关键字中所有单词字母都小写。

2、标识符的规则：
标识符的组成：由26个字母的大小写，0-9十个数字，还有 _和$。
注意定义合法标识符的规则：
1、数字不可以开头。 2、不可以使用关键字。 java中严格区分大小写。
java中的命名规范：
包名：多单词组成时所有字母都小写。aaddcc

类名和接口名: 多单词组成时，所有单词的首字母大写。ForTest

变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每一个单词的首字母大写。xxxYyyBbb

常量名：所有单词字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ

3、注释
单行注释// 多行注释/注释内容/ 文档注释/*注释内容/文档注释是java的特有注释。

4、Constant常量
常量表示不可以改变的数值。
java中常量的分类:
1、整数常量 负数的二进制的表现形式取反后加1
2、小数常量
3、布尔型常量 ture false
4、字符常量
5、字符串常量
6、null常量 （只有引用数据类型才能用）

4.1、变量

思想：只要有不确定的数据那就定义一个变量进行存储。

变量的概念：内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型）；该区域的数据可以在同一类型范围内不断变化。

定义变量的格式： 数据类型 变量名=初始化值;

使用变量注意：变量的作用范围（一对{}之间有效）在同一区间内不能定义两个变量相同数据类型不同的数据。

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。

数据类型包含两部分：1，基本数据类型。2，引用数据类型。

1，基本数据类型      
　整数类型  byte  short（2个byte）  int （4byte） long      
          byte占一个八位  8个二进制位表示一个字节。   

　浮点类型  float（单精度 占4byte）  double(双精度  占8byte)

　字符型 (char)(取值范围 0——6535)（占2byte，16个二进制位）

　布尔型  (boolean)  ture   false

2，引用数据类型  
　　接口 interface
　　类  class
　　数组  []

整数类型默认是  int类型          小数类型默认是 double错误:    

duplicate（重复） local variable 意思：定义了两个同名变量
什么时候定义变量？ 当数据不确定时，需要对数据进行存储时，就定义一个变量进行存储。

4.2、类型转换

自动类型提升：

强制类型转换 ：
此处容易出现的错误提示；
（cannot be resolved to a variable无法解决的一个变量）
Syntax error on token 语法错误括号加错位置。例 错误：byte b=4; b= (byte)b+2;
Type mismatch: cannot convert from int to byte（类型不匹配:不能从int转换为字节）；例：b= (byte)b+2

5、运算符

5.1 算术运算符： %取模 （求商取余数）x%y 左边小于右边模数是左边，右边为1模数为0。2%5=2
如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论。
++ –; +
注意： b=a++与b=++a 例 int a=2,b; b=a++ 意思：a先将自己的值赋给b然后再自增a=a+1。结果：a=3,b=2。

区别于 b= ++a; 意思先进行a自增然后在赋值给b此时a=b。

• :表示字符串的相连接。字符串数据和任何数据使用+都是相连接，最终都会变成字符

  5.2 赋值运算符:
  = ,+= ,-=,%=,*=, /= short x=3; x+=4(区别于x=x+4);
  x+=4在编译时+=在赋值的同时，自动完成了强转的动作。
  5.3 比较运算符：
  == !=
  比较运算符的结果都是boolean类型，也就是要么是true，要么是false。== 相等于 比较运算符 结果true 或false
  注意这有个instanceof这个比较运算符是个关键字。它的作用是判断其左边对象是否为其右边类的实例，返回boolean类型的数据。
  5.4
  逻辑运算符：

    逻辑运算符用于连接布尔型表达式
  

&与 | 或 ^ 异或 &&（短路）||（短路）

&”和“&&”的区别：
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。

异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

5.5位运算符:

<< 左移 >>右移 ^异或

一个数异或同一个数两次，结果还是那个数。例7^4^4=7

5.6 三元运算符:
格式： （条件表达式）？表达式1：表达式2;

如果条件为true，运算后的结果是表达式1；

如果条件为false，运算后的结果是表达式2。

 比较两个数最大值：

class  TernaryOperatorDemo{
    public static void main(String[] args){
     int x = 3,y=10,z;
     z=(x>y)?x:y;
     System.out.println("z="+z);
     }

}

5.1.1 转义字符：

通过\改变后面字母或者字符的含义。例：”\”hello world\”“得到一个带双引号的”hello world”

\n:换行 \b 退格 相当于backspace \t 制表符 相当于table键
window系统中回车符由 \r\n两个字符组成。

6、语句
程序流程控制：

注：条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false;
6.1 判断结构：
1、if（条件表达式）
{
执行语句；

}

2、if（条件表达式）
{
执行语句；
}
else
{
执行语句；
}
**注：if else简写格式：变量 = （条件表达式）？表达式1：表达式2；
优点：可以简化代码。
弊端：因为是一个运算符，所以运算完必须有一个结果。**
3、if(条件表达式)
{
执行语句；

}
else if (条件表达式)
{
执行语句；
}
……

else
{
执行语句；
}
if else if else 这种格式整体被看做一个整体。

6.2 选择结构：
switch语句格式：
switch(表达式)
{
case 取值1：
执行语句；
break;
case 取值2：
执行语句；
break；
case 取值3：
执行语句；
break；
……
default:
执行语句；
break;
}
注意switch语句特点：
a,switch语句选择的类型只有四种：byte，short，int ， char。
b,case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
c,结束switch语句的两种情况：遇到break，二是执行到switch语句结束。
d,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。
6.3 循环结构：
代表语句：while ,do while ,for
1、while语句格式：

while（条件表达式）
{
执行语句；
}
中文格式：定义一个初始化表达式；
2、do while语句格式：
do{
执行语句；
}
while（条件表达式）； 注意：do while 处while结束用分号 而while循环不能。

**do while特点是条件无论是否满足，
循环体至少被执行一次**

3、for

for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
注：
a,for里面的表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复整个过程，直到条件不满足为止。

b,while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
C、最简单无限循环格式：while(true) {}, for(;;){},无限循环存在的原因是并不知道循环多少次，
而是根据某些条件，来控制循环。
其他流程控制语句:

break(跳出)， continue(继续)

break语句：应用范围：选择结构和循环结构。

continue语句：应用于循环结构。特点是结束本次循环继续下一次循环。

注：d,标号的出现，可以让这两个语句作用于指定的范围。w: q: break q; 结束q标号的语句。

c,continue语句是结束本次循环继续下次循环。
b,这个两个语句单独存在下面都不可以有语句，因为执行不到。
a,这两个语句离开应用范围，存在是没有意义的。

7、函数
函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
函数的格式：
修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2……）
{
执行语句；
return 返回值；
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该值会返回给调用者。

定义一个功能完成一个整数的*3+5的运算
class FuncationDemo{
public static int getResult(int x ){
return x*3+5;
}
public static void main(String[] args){
int num = getResult(10);
System.out.println(num);
}
}
7、2 函数的特点
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用才会被执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
注意：函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。

7、3 函数的应用
如何定义一个函数呢？
第一，明确要定义的功能最后的结果是什么？ （确定函数的返回值类型）
第二，明确在定义该功能的过程中，是否需要未知内容参与运算。 （为了明确参数的类型和 形式参数）
示例：
需求：定义一个功能，可以实现两个整数的加法运算。
分析：
该功能的运算结果是什么？两个数的和，也是一个整数(int)
在实现该功能的过程中是否有未知内容参与运算？加数和被加数是不确定的。(两个参数int，int)
代码：

    public static int  getSum(int x,int y)
        {
            return x+y;
        }

需求定义一个功能判断两个整数是否相同:

   public class FuncationDemo1 {
        public static void main(String[] args) {
        boolean b = compare(5,5);
        System.out.println(b);

    }

    public static boolean compare(int x, int y) {
        /* if(x==y)
             return true;
             //else
           return false;*/
        //return (x==y)?true:false;

        return x==y; //注意比较运算符本身就会产生一个Boolean。
    }

代码块示例：需求定义一个功能，对两个数进行比较取较大的那个数。

public static int getMax(int x , int y){
return(x>y)?x:y; //三元运算符 最后有一个结果的。

}

7、4 函数的重载（overload）
函数重载的概念：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表。
函数重载的好处：
方便于阅读，优化了程序设计。
重载示例：
//返回两个整数的和

public static int add(int x, int y){
    return x+y;
}

//返回三个整数的和

public static int add(int x, int y, int z){
    return x+y+z;
}

//返回两个小数的和

public static double add(double a; double b){
    return a+b;
}

什么时候用重载呢？
当定义的功能相同，但参与运算的未知内容不同时，那么这时就定义一个函数以表示其功能，方便阅读，而通过参数列表的不同加以区分多个同名函数。

8、数组
8、1 数组的定义：
数组的概念：
同一种类型数据的集合。 其实数组就是一个容器。
数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
数组的格式：
格式1：
元素类型[ ] 数组名 = new 元素类型 [ 元素个数或数组长度 ]；
例：
int[ ] arr = new int [ 5];
格式2：
元素类型 [ ] 数组名 = new 元素类型[ ]{元素，元素，……};
int [ ] arr = new int[ ] {3,5,1,7}; //数组
或者：int[] arr = {3,5,1,7};

调用数组时格式是：数组名[ index]
需求：定义一个能存储三个整数的一个容器。

int[] x = new int [3];     //数据类型中引用数据类型  数组 []    x的数据类型就是数组。

8、2 内存结构
//Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分
//因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存：
用于存储局部变量，当数据使用完，所占空间会自动释放。
什么是局部变量？局部变量（定义在方法中的变量、定义在方法参数上的变量、定义在for循环中 的变量）
例如：

  int a =8  ;
  int b=a;
  b=5;
  System.out.println(a);   打印结果是  a=8 在栈内存分布的变量块中a的值不变，而b的变化。
  ```
例如：
int [] x = new int [3];
int[ ] y = x ;
x=null;
注意此时堆内存中不会产生垃圾。   这是引用数据类型特点，x,y的引用同时指向了堆内存中对象，当x为null时，y的引用还指向堆内存中的数组。

int[] x = new int [3];
在此处x会在栈内存。
对象 new int [3]在堆内存中。

堆内存：                                                           
1、通过new建立的实例都存放在堆内存中， 数组和对象。
2、每一个实体都有内存地址值。
3、 实体中的变量都有默认初始化值。
4、实体不在被使用，会在不确定的时间内被垃圾回收器回收
 (堆内存的特点每一个实体都有一个内存地址值，实体中的变量都有一个默认的初始化值。)
方法区，本地方法区，寄存器。
![这里写图片描述](https://img-blog.csdn.net/20160627220514665)


8、3   数组操作常见问题:
I、数组脚标越界异常(ArrayIndexOutOfBoundsException)
例：

public class ArrayDemo1 {
public static void main(String[] args) {
int [] arr = new int[3];
System.out.println(arr[3]);
}
}
异常提示：Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
访问到了数组中的不存在的脚标时发生的异常。

II、空指针异常(NullPointerException)
例：

int [] arr = null;
System.out.println(arr[0]);
arr引用没有指向实体值为null，却在操作实体中的元素时。

8、4 数组中常见的操作：
1、数组的遍历
数组中有一个属性可以直接获取到数组的长度。 length、 调用方法是 数组名.length。

例：
/*
获取数组中的元素，用到的是遍历。
*
*/

public class ArrayDemo2 {
    public static void main(String[] args)
     {
        //  int [ ] arr =new int [] {3,6,7,10,65,23};
          int [ ] arr = {3,6,7,10,65,23};
          //int sum=0;
          for(int x =0; x<arr.length;x++)
        {
            System.out.println("arr["+x+"]="+arr[x]);
            //sum+=arr[x];
        }
    //System.out.println("sum="+sum)；//利用累加和遍历思想求得数组中元素的和。
   }
}

2、选择排序：
利用角标 将元素进行顺序排列，用到for循环嵌套和临时变量将两个数互换位置。 （就是第一个角标的元素和每一个角标的元素进行比较然后互换位置）
3、冒泡排序：
冒泡排序就是相邻的两个元素进行比较进行，符合条件就换位。
第一圈最值就出现在了最后位。
8、5 数组中的数组

二维数组 [] []
格式1：int[][] arr = new int[3][2];
定义了名称为arr的二维数组;
二维数组中有3个一维数组;
每一个一维数组中有2个元素;
一维数组的名称分别为arr[0], arr[1], arr[2];
给第一个一维数组1脚标位赋值为78写法是: arr [ 0][ 1]=78;

格式2：int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;
注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。

---

java反射：
反射就是把java类中的各种成分映射成相应的java类。
反射的基石Class类。 注意区别于关键字class
Class类的定义：java程序中的各个java类属于同一类事物，描述这类事物的java类名就是Class。
注意得到各个字节码对应的实例对象（Class类型）有三种方式：
1、类名.class eg、System.class
2、对象.getClass() eg、 new Date().getClass();
3、Class.forName(“类名”) eg、Class.forName(“java.util.Date”)
成员变量Field的反射 当成员变量为私有属性时注意Object.getClass().getDeclaredField()；
这样就能获得私有的成员变量。 fielda.setAccessible(true);就可以打印得到成员变量上的变量值。

public class ReflectPoint {
    private int a;
    public int b;
    public ReflectPoint(int a, int b) {
        super();
        this.a = a;
        this.b = b;
    }
    //三个字符串私有 成员变量
    private String str1="abc";
    private String str2="basketball";
    private String str3="all";
    @Override
    public String toString() {
        return "ReflectPoint [str1=" + str1 + ", str2=" + str2 + ", str3="
                + str3 + "]";

    }



import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class ReflectClassTest {
    public static void main(String[] args) throws Exception 
    {
        String  s1= "abc";
        Class clazz= s1.getClass(); 
        Class cls1 = String.class;
        Class cls2= Class.forName("java.lang.String");
        System.out.println(clazz==cls1);
        System.out.println(clazz==cls2);
        System.out.println(clazz.isPrimitive());// false判断类的字节码是不是基本类型
        System.out.println(int.class.isPrimitive())// true
        System.out.println(int.class==Integer.class);
        System.out.println(int.class==Integer.TYPE);
        System.out.println(int[].class.isPrimitive());
        System.out.println(int[].class.isArray());//判断字节码文件是不是数组类型的
        //new String(new StringBuffer("abc"));
            Constructor constuctor= String.class.getConstructor(StringBuffer.class);  //构造函数的反射
         String s2  =   (String)constuctor.newInstance(new StringBuffer("abc"));
         System.out.println(s2.charAt(2));
         System.out.println(s2);
         ReflectPoint pt1= new ReflectPoint(3,5);
         Field fieldB= pt1.getClass().getField("b");
         System.out.println(fieldB);
        System.out.println(fieldB.get(pt1)); 
        Field fielda= pt1.getClass().getDeclaredField("a");
        fielda.setAccessible(true);

        System.out.println(fielda.get(pt1));
        changeStringValue(pt1);
        System.out.println(pt1);

}
  //改变成员变量中的字符串  使他们中带字符a的改成字符b
    private static void changeStringValue(Object obj) throws Exception {

        Field[] fields= obj.getClass().getDeclaredFields();

        for(Field field:fields){
            if(field.getType()==String.class)
            {   
                field.setAccessible(true);
                String  oldValue=(String)field.get(obj);
                String  newValue = oldValue.replace("a","b");
                field.set(obj, newValue);

            }
        }


    }
}

//结果：ReflectPoint [str1=bbc, str2=bbsketbbll, str3=bll]