Java基础学习（一） -- Java环境搭建、数据类型、分支循环等控制结构、简单一维数组详解

一：java概述：

1982年，SUN公司诞生于美国斯坦福大学校园，并于1986年上市，在NASDAQ（纳斯达克：是全美证券商协会自动报价系统）的标识为SUNW，2007年改为JAVA。

2009年4，美国数据软件巨头甲骨文公司（Oracle）宣布以74亿美元收购SUN公司，从此Java归属于甲骨文公司。

1999年SUN公司发布了基于Java的三个平台技术标准：J2SE,J2EE,J2ME。

2005年开始分别改名为：JavaSE，JavaEE，JavaME。

二：配置java环境：

JDK：Java Development Kit，java的开发和运行环境。
JRE：Java Runtime Environment，java程序所处的运行环境。
Java虚拟机（Java Virtual Machine），简称JVM，它是运行所有Java程序的虚拟计算机，好比是街机游戏的模拟器。JVM是Java程序的解释和执行器。
步骤：

安装JDK，去JDK的官网下载（不要下载最新版本，尽量使用比低版本低一个版本的JDK，以达到兼容绝大多数设备）。
配置PATH环境变量
安装IDE工具（Myeclipse/eclipse）

三：java语法基础：

1.java的命名规则

帕斯卡命名法：首单词的首字母大写，后续所有单词首字母也大写。类、接口、枚举。
驼峰命名法：首单词的首字母小写，后续所有单词首字母大写。方法名、变量名。
包名：网址倒写，com.网址.工程.包名，所有字母小写。

2.常量：是在程序中的不会变化的数据。经常用关键字final定义。

3.变量：其实就是内存中的一个存储空间，用于存储常量数据。（可以重复使用使用）。

4.标识符：在写代码的时候为了增强代码的阅读性会自定义很多名字，比如：类名，方法名，变量名等。
标识符命名规则：

由字母、数字、下划线、$组成，不能以数字开头。
不得使用java中的关键字和保留字。
不用Java中以已经定义好的类名作为自己的类名。

5.数据类型

　　基本数据类型：按值传递，传递复本，修改复本不会影响原数据。

　　引用数据类型：按引用传递，传递的是指针，如果修改会影响原有数据。

基本数据类型：Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

引用数据类型：除了8种基本数据类型，其他绝大多数都为引用数据类型，包括类、接口、数组。引用数据类型默认初始值都是null。

6.基本数据类型之间的转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
数据类型转换必须满足如下规则：
1. 不能对boolean类型进行类型转换。
2. 不能把对象类型转换成不相关类的对象。
3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
4. 转换过程中可能导致溢出或损失精度。
5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入。

注意：在8大基本数据类型中,boolean不属于数值类型,不参与转换.

隐式转换：当把数据范围较小的数据赋给另一个数据范围较大的类型的时候，Java可以自动进行类型转型。

强制转换：当把数据范围较大的数据赋给另一个数据范围较小的类型的时候，此时Java不再能自动转换，需要在数据前边强制加上要转换的类型的名称。

6.Java的运算符

分为四类：
算数运算符、关系运算符、逻辑运算符、位运算符。
算数运算符(9个)：+ ， - ， * ，/， % ， ++ ， --（加，减，乘，除，取余，加1，减1）
关系运算符(6个)：==， != ，>， >= ， < ， <= （等于，不等于，大于，大于等于，小于，小于等于）
逻辑运算符(6个)：&&， || ，! ， ^， & ， | （与，或，非，异或，逻辑与，逻辑或）
位运算符(6个)：& | ~ ^ >> << （位与，位或，位非，位异或，右移，左移）

其中算术运算符和关系运算符比较简单，和我们在数学中的是一样的算法和优先级（先算乘除再算加减，有括号的先算括号里面的）。

逻辑运算符：

　　 && 短路与两边都为真才是true ，但如果左边为假，右边条件不再计算也不再关注
      ||     左右两边一个为真即为真
      !      非也叫取反，右边为真结果为假，右边为假结果为真
      &     按位与    先将左右两边的表达式转化成二进制数后分别按每一位进行与操作，假假为假，真真为真，将与操作的结果的二进制数转化成十进制
"++"和"--"用于数值变量之前，在赋值操作中，先对被”++“或”--“操作变量值先加1或者先减1，然后在进行其他的操作；
"++"和”--“用于数值变量之后，在赋值操作中，先用被”++“或”--“的操作变量值进行其他的操作，然后在对其值加1或者减1。

位运算符：不常用，这里就不详述。

三元运算符
格式：表达式？值1：值2 如果表达式为真，取值1，表达式为假，取值2。

7.Java 分支结构 - if...else/switch

　　分支结构有两种：if和switch。

　　　　其中if分为if...else 和 if...else if ...else结构。

　　　　swich只有一种，即swcih..case

 1 if语法：条件为true或者false
 2 if(条件){
 3     语句;   
 4 }else｛
 5 　　语句；
 6 ｝
 7 
 8 
 9 if..else if ....else 语法：
10 if(条件){
11 　　　　语句;
12 　　}else if(条件){
13 　　　　语句；
14 　　}else｛
15 　　　　语句；
16 　　｝
17 
18 
19 swich语法：表达式为变量的判断值
20 switch(整型表达式){
21     case A:
22             表达式结果等于A时，执行此语句；
23     break；
24     case B:
25             表达式结果等于B时，执行此语句；
26     break；
27     default:
28         以上值都不满足时，执行此语句；
29     break；
30

8.Java 循环结构 - for, while 及 do...while

　　　　while循环　　　　　　　　　　　　　　　　do..while循环　　　　　　　　　　　　　　　　　　　　for循环

while循环和do..while循环大部分情况下用于不确定循环次数的死循环，但是do..while循环必须先执行一遍循环后再进行判断，然后再决定走不走循环，而while循环则是先判断后循环。

for循环用于限定次数的循环。因此绝大多数下使用for循环进行循环遍历。

 

while循环语句：

 while (条件 {
        循环语句；    
        }
        

do..while循环语句：

        do {
            循环语句;
        } while (条件);


for循环语句：

for (int i = 0; i < args.length; i++) {//初始值，循环次数，循环增加（减少）
    循环语句；
}

注意：嵌套循环时，输出图形的时候外层代表行，里层代表列。

 1 package com.jianglai.day02and03;
 2 
 3 public class Demo07 {
 4 
 5     public static void main(String[] args) {
 6         
 7         
 8         
 9         
10         /**
11          * [图形题做题思路]
12          * 外层循环控制行数，内层循环控制每行中元素的个数。
13          * 
14          * ① 确定有几行， 这就是外层循环的次数
15          * ② 确定每行中有几种元素， 这就是内层循环的个数
16          * ③ 找出每行中每种元素，与行号之间的关系； 这就是每个小循环的循环次数。
17          */
18                     /**
19                              *
20                             ***
21                            *****
22                           *******
23                          *********
24                          
25                          行号    空格    星号
26                          1    4    1
27                          2    3    3
28                          3    2    5
29                          4    1    7
30                          5    0    9
31                          i    5-i 2*i-1
32                      */
33         for (int i = 0; i <= 5; i++) {
34             
35             
36             for (int z = 0; z < 5-i; z++) {
37                 System.out.print(" ");
38             }
39             
40             for (int j = 1; j < i*2; j++) {
41                 System.out.print("*");
42             }
43             System.out.println();
44         }
45         
46         
47                         /**
48                              A
49                             ABA
50                            ABCBA
51                           ABCDCBA
52                          ABCDEDCBA
53                          
54                          行号    空格    递增    递减
55                          1    4    1    0
56                          2    3    2    1
57                          3    2    3    2
58                          4    1    4    3
59                          5    0    5    4
60                          i    5-i    i    i-1
61                      */
62         
63         for (int i = 1; i <= 5; i++) {
64             for (int j = 0; j < 5-i; j++) {
65                 System.out.print(" ");
66             }
67             
68             char c= 'A';
69             
70             for (int z = 1; z <= i; z++) {
71                 System.out.print(c);
72                 c++;
73             }
74             
75             for (int k = i-1; k > 0; k--) {
76                 c--;
77                 System.out.print((char)(c-1));
78             }
79             
80             System.out.println();
81         }
82 
83     }
84 
85 }

斐波那契数列：

        int n = 1;
        int m = 1;
        int z = 0;
        System.out.print("斐波那契数列前20项："+n+","+m+",");
        for (int i = 1; i <= 18; i++) {
            z = n+m;
            n = m ;
            m = z;
            System.out.print(z+",");
        }
        System.out.println();

九九乘法表：

        /**
         * 九九乘法表
         */
        for (int j = 1; j <= 9 ; j++) {
            for (int k = 1; k <= j; k++) {
                System.out.print(j+"*"+k+"="+j*k+"	");
            }
            System.out.println();
        }

注意：break：结束当前循环，执行当前循环体后面的语句。continue：表示跳过此次循环，继续执行下一次循环。

9.Java 数组

数组是相同类型的变量按顺序组成的一种复合数据类型，称这些相同类型的变量为数组的元素或单元。

数组中的每一个数据称之为元素，数组中的元素存放的位置称为索引，索引从0开始，每一次都递增1。

数组的定义： 
int[] a = new int[5];   //直接new出来数组，然后定义长度
int[] a = {1,2,3,4,5};  //直接定义数组，再加数据，由数据定长度。
int[] a = new int[] {1,2,3,4,5};  //new出来数组 ，再由数据定义数组长度

数组的初始化分为静态初始化和动态初始化：
静态初始化是在声明数组的同时进行赋值;   int[] a = {1,2,3,4,5}
动态初始化是在声明数组后在对其进行赋值。int[] a = new int[5];a[0]=0;  a[1]=1;a[2]=2;a[3]=3;a[4]=4;

数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者foreach循环。
 

foreach循环  也称为  for循环的增强版
JDK 1.5 引进了一种新的循环类型，被称为foreach循环或者加强型循环，它能在不使用下标的情况下遍历数组。但是它只能全部输出，不能按需求输出。
代码：
int[] arr = {1,2,3,4,5}; 
for (int i : arr) {
System.out.println(i);
}
基本类型和引用类型在内存中的保存
Java中数据类型分为两大类，基本类型和对象类型。相应的，变量也有两种类型：基本类型和引用类型。
基本类型的变量保存原始值，即它代表的值就是数值本身；
而引用类型的变量保存引用值，"引用值"指向内存空间的地址，代表了某个对象的引用，而不是对象本身，
对象本身存放在这个引用值所表示的地址的位置。


变量的基本类型和引用类型的区别
基本数据类型在声明时系统就给它分配空间，即给它分配堆内存的地址。
引用则不同，它声明时只给变量分配了引用空间，而不分配数据空间，也就是只在栈内存中存放了目标对象的首地址（数组或者对象的首地址），而首地址指向的是堆内存中第一个数值。
 
引用传递和值传递
基本数据类型的值传递：基本数据类型定义好值后就存放在堆内存中，将赋值完成的变量赋值给另一个变量，后面方法中的操作再去对值进行修改，不影响实际参数的值。
引用数据类型的值传递：实参的引用(是地址而不是参数的值)被传递给方法中相对应的形参，那么接收到的还是原始值的内存地址；在方法执行中，形参和实参内容相同，指向同一块内存地址，那么更改数值，所指向的第一个数也就会改变，也就是所定义的数组名或者变量名所在地址指向的数值也随之改变。
 
 