标签：打印   java   efault   嵌套   进入   oat   算术   rgs   必须   

注意：一个java代码文件中,可以包含多个类
  一个java代码文件中,只能有一个类是被public修饰的
  一个java代码文件中,代码文件名称必须和public修饰的类的类名称一样！！！

  编译源码成字节码文件.class文件（与平台无关的字节码文件），再解释执行

2.第一个java程序 //定义类HelloWord
public class HelloWorld

//定义程序入口方法
public static void main(String[] args){
//打印数据至控制台
System.out.println("===欢迎加入疯狂软件===");

 }

} 3.jvm那边 4.注释 5.变量 java是【强类型】语言：变量必须先定义出来,变量必须拥有自己的类型,才能使用！

变量是可以在定义出来以后修改值的。
变量只能存储对应变量数据类型的数据
6.标识符 变量的名称就是一个标识符 标识符一般用于在编程中取名字。 7.数据类型 java的数据类型分为两种： 1.基本数据类型(8种)： a.数值类型

1个byte 相当于在计算机底层占8位
bit(b):位 只可能是0或者1
byte(B): 字节 1B = 8b 一个字节等于8位

        -- 整形(整数)   1 2 100
          byte(字节型)      取值范围是 -128～127    底层占8位 （1个Byte）
          short(短整型)     取值范围是 -32768～32767   底层占16位（2个Byte）
          int (整型)           取值范围是 -2G～2G-1         底层占32位
          long (长整型)     取值范围是 -2的63次方～2的63次方-1   占64位（8个Byte）

            -- 浮点型(小数)  1.1  100.01
          float(单精度浮点类型)  底层占32位（4个Byte)
          double(双精度浮点类型)  底层占64位（8个Byte)

    b、 char(字符型)  ：字符只能是单个字符 并且应该包含在(单引号)‘ ‘中
         字符也占2个字节（16位），可以表示65536个字符。

c.boolean(布尔型) :boolean类型对应的值只有 true false

2.引用数据类型：
数组,类,接口
8.类型转换 ——所有数值型（byte、short、int、long、float、double、char）之间都可以相互转换。

★自动转换

byte → short → int → long → float → double
                           ↗
                       char

被转换的数据在要转换类型的范围之中,可以自动转换！！

超出了范围,就要强转: 类型A 变量 = (类型A)数据; 强转会出现数据溢出！

所有数值类型，都可以自动转换为double类型
所有整数类型，都可以自动转换为long类型。
所有整数类型，都可以自动转换为浮点类型（float、double）   

大范围转小范围必须强转。
如果大范围数据也在小范围数据之类一般不会溢出。
重点：浮点型转换成整形,先去掉小数点,再判断范围,再转换。

避免溢出!!
9.字符型和字符集 就是给已有的字符编个号码。 10.运算符 1.算术运算符 ++、--、+、-、*、/(除)、%(求余/取模)

注意：++ -- 自增和自减
a++,++a 相当于 a = a+1;
a--,--a 相当于 a = a-1
在表达式中：++在前先做自增再计算表达式。--在前先做自减再计算表达式，反之。
2.赋值运算符

先计算右侧,再将右侧的结果复制给左边的变量。

  int a = 3+4;

3.比较运算符

<

<=

!=

【注意：】比较运算符只是比较两边的值，不会理会它们的数据类型。
 比较运算符得到的结果，一定是布尔型：true、或 false。

4.三目运算符
条件表达式 ? 表达式1 : 表达式2

 如果条件表达式为真，整个结果返回 表达式1 的值；否则就返回 表达式2 的值。

三目运算符一定有一个返回值。所以必须是表达式！不能是执行代码。
5.扩展的赋值运算符1
=可与其他双目运算符结合，从而得到功能强大的赋值运算符。
-- 最终的结果一定需要成为左侧变量的类型。但是是自动帮你转型的！！
a += b 相当于 a = (a的类型)(a + b) a -= a 相当于 a = (a的类型)(a - b) = a=b a=(a的类型)(a*b) /= %= a%=b a =(a的类型)(a%b); &= |= ^= 6.逻辑运算符 逻辑运算符要求2个操作数一定是boolean类型（true、false）

&& ： 与（并且，要求两个操作数都为true，结果就是true）
& ： 不短路与。　即使前一个表达式已经是false，它还会继续计算后面的表达式。
|| ： 或（或者，要求两个操作数一个为true，结果就是true。
| 不短路或。 即使前一个表达式已经是true，它还会继续计算后面的表达式。
! ： 非（不要，原操作数取反。单目运算符）
^ ： 异或。 不同时为true，相同时为false
11.表达式类型的自动提升 public class BiaodashiLeixing { public static void main(String[] args) { // 定义一个字节整形 byte bt = 23 ;

// 看一个表达式的最高类型,最高类型是什么,表达式最终的类型就是什么。
long b = bt +10l ;

 System.out.println(b);

 int c = 10 ;
 long db = 10L*c*34.2f;
 System.out.println(db);

}
} 12.流程控制语句 （1）顺序结构 不加任何控制的代码，就是顺序结果。 程序在每个方法中，必须先执行前面代码，再执行后面的代码，就是按照顺序执行。如果前面代码出错，后面代码无法获得执行的机会。 （2）分支结构 1.if分支

语法格式：

结构1 ：
if(条件){
    // true 执行这里
}

结构2 ：
if(条件){
     // true 执行这里
}else{
     // false 执行这里
}

结构3 ：
if(条件){
     // true 执行这里
}else if(条件){
     // true 执行这里
}else if(条件){
     // true 执行这里       else if : 0 ~ N 个
}else if(条件){
     // true 执行这里
}else{

}

结构4 ：
  if(条件){
      // 执行代码

}

 2.switch 分支 

switch(表达式){
     case 值 ：
     // 执行代码
     break; // 结束分支
     case 值 :
     // 执行代码
     break; // 结束分支     0 ~ N 次 case块！
     case 值 :
     // 执行代码
     break; // 结束分支
     default:
     // 执行代码
     break; // 结束分支
}

  【注意点：】
   A. switch表达式的类型，可以是 byte、short、int、char、String（Java 7之后才行）、枚举。
   B. case块后省略了break之后，会发生“贯穿”（fallthrough）。
      贯穿：程序会从第一个匹配的case块开始执行，在遇到break之前，根本就不会去比较与case后的值是否相等，
        而是直接执行case块。
        --- 所以不能省略break

   C.case后面的值必须与比较的类型一致。
   3.循环结构
        1.while循环
格式： while(循环条件){
          // 执行代码 循环体
   }
        流程：程序先判断 循环条件 是否为true，如果循环条件为true，进入并执行循环体。
    循环体执行结束之后，再次判断 循环条件 是否为true，如果循环条件为true，进入并执行循环体。
    直到某一次循环条件变成了false，不再执行循环体，结束循环。

    循环条件的执行次数 == 循环体的执行次数 + 1
因为最后一定要多一次循环条件判断为false

2.do-while循环
do{
// 循环体
}while(循环条件);

流程：程序先执行一次循环体。
判断 循环条件 是否为true，如果循环条件为true，进入并执行循环体。
循环体执行结束之后，再次判断 循环条件 是否为true，如果循环条件为true，进入并执行循环体。

直到某一次循环条件变成了false，不再执行循环体，结束循环。

循环条件的执行次数 == 循环体的执行次数

对于do while循环而言，即使循环条件开始就是为false，循环体也会执行1次。

3.for循环

  for(初始语句 ;循环条件 ; 迭代语句){

        // 循环体

   }

      流程：开始，执行初始化语句，但只执行一次。
      程序先判断 循环条件 是否为true，如果循环条件为true，进入并执行循环体。
      循环体执行结束之后，执行迭代语句，再次判断 循环条件 是否为true，如果循环条件为true，进入并执行循环体。

      直到某一次循环条件变成了false，不再执行循环体，结束循环。

      循环条件的执行次数 == 循环体的执行次数 + 1

      循环体执行次数 = 迭代语句的执行次数

13.break，continue，return关键字 break:结束当前分支或者循环。 1、break只能结束当前（switch）分支或者循环 2、如果是嵌套循环,内部循环的break将不会影响外部循环的执行。

3、如果在嵌套循环中,希望结束外部循环,应该给外部循环加上标签，再通过
break 外部循环标签;来结束外部循环执行。
return: 1、一般直接写return;结束程序。 2、 如果return 数据;返回数据给调用者。

continue： 1、continue：忽略本次循环的循环体内剩下的语句，重新开始执行下一次循环体。

【隐藏意思：】 把continue放在单次循环的循环体的最后，是没有任何意义的。

continue放在嵌套循环中,可以同给外部循环加入标签,内部循环就可以通过continue 标签；

来忽略外部循环当次循环体的剩下代码,而直接进入下一轮计数器,从新执行循环体。
continue 标签;
14.数组 冒泡排序 为什么需要数组？

当程序中有多个（甚至个数暂时不确定的）类型相同、功能类似的变量时，此时就不要用变量，而是应该用数组。
—一【创建】数组之后，就相当于得到了N个类型相同的变量，每个数组元素都相当于一个普通的变量。
数组的长度： 该数组包含多少个元素。

如何创建使用数组？

数组是一种引用类型。如果创建不同类型的数组来存放数据。

基本数据类型                数组类型 
byte                            byte[] 
short                           short[] 
int                               int[] 
long                            long[]
char                            char[]

float                          float[]
double                      double[]
boolean                     boolean[]
                              ...

注意：什么类型的数组只能存放什么类型的数据

15.创建数组的两种方式 静态初始化
格式：类型[] 数组变量名称 = new 类型[]{元素1,元素2,元素3,..........};

-- 数组的长度 格式: 数组变量名称.length
-- 访问数组的元素 格式: 数组变量名称[元素位置索引]
-- 给数组元素赋值 格式: 数组变量名称[元素位置索引] = 值;
-- 遍历数组： 访问数组的所有元素
a. for循环
b. foreach循环
格式: for(数组中元素的类型 变量 : 需要被遍历的数组){
//输出变量
}
注意点：
-- 什么类型的数组就一点存放什么类型的数据
-- 静态初始化的数组一旦定义出来,数组的长度就固定了。
-- 访问数组的时候,访问的索引不能超过数组的大小,超过代码在执行
的时候会出现一个经典的错误：数组访问越界异常(ArrayIndexOutOfBoundsException)！
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: x

动态初始化
格式：类型[] 数组变量名称 = new 类型[数组的长度];
-- 数组的长度 格式: 数组变量名称.length
-- 访问数组的元素 格式: 数组变量名称[元素位置索引]
-- 给数组元素赋值 格式: 数组变量名称[元素位置索引] = 值;
-- 遍历数组： 访问数组的所有元素
a. for循环
b. foreach循环
格式: for(数组中元素的类型 变量 : 需要被遍历的数组){
//输出变量
}
注意：
-- 什么类型的数组就一定要存放什么类型的数据
-- 动态初始化一旦定义出数组,数组的长度就固定了。
此时数组中是存在元素的,元素是默认的值：
所有的数值类型默认值都是： 0 或者 0.0
boolean类型数组的默认值是： false
char类型的默认值是：一个空格字符。
所有的引用类型数组默认值是： null

               -- 访问数组的时候,访问的索引不能超过数组的大小,超过代码在执行
                的时候会出现一个经典的错误：数组访问越界异常(ArrayIndexOutOfBoundsException)！
            Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException:

16.栈内存，堆内存 Java的变量的存放区域，有两个地方：

按照操作系统的原理：程序必须加载到内存中才能执行。

注意点： 数组是一个引用类型。
java的存储机制：方法申明的变量全部都放在栈内存,但是
-- 基本数据类型是直接存放变量的值在栈内存中，输出变量直接打出存放的变量值。
-- 引用类型的变量在栈内存中并不是存放变量的内容,而是存放
引用类型变量对应数据在堆内存中的地址。
栈（stack）内存： 方法（函数）运行时动态分配的一小块临时内存，方法（函数）结束时，内存区就被系统回收。 方法栈。

只要在方法声明的变量（局部变量），全部都放在栈内存。
堆（heap）内存： JVM（Java Virtual Machine）运行时持有一块持久的、很大存储区。 一个虚拟机，只持有一块堆内存。 运行java命令时，可通过-X选项来指定堆内存的大小。 只要用new创建的对象，全部都在堆内存。 引用类型变量的值一般都是存放在堆内存中的
17.二维数组 char[][] datas = new char[3][3]; //遍历二维数组 datas:二维数组 data:一维数组

for(char[] data : datas ){

 for(char da : data){
     System.out.print(da);
 }
 System.out.println();

}

1 面向对象前部分

标签：打印   java   efault   嵌套   进入   oat   算术   rgs   必须   

原文地址：http://blog.51cto.com/10913595/2070693