java最小的数据类型 java中最小的程序单元是

Java学习：

1. 第一个Java 程序： 

public class HelloWorld

{

     //Java程序入口方法，程序将从这里开始执行

     public static void main (String [] args)

  {

     //向控制台打印一条语句

        System.out.println("HelloWorld!");

   }

}

• Java 程序是一种纯粹的面向对象的程序设计语言,因此 Java程序必须以类(class)的形式存在,类(class)是 Java 程序的最小程序单位。Java 程序不允许可执行性语句、方法等成分独立存在，所有的程序部分都必须放在类定义里。
• 最简单的Java程序只包含一个空类定义的程序：

class Test

 ｛

  ｝

  >>这是一个最简单的 Java 程序，这个程序定义了一个Test 类，这个类里没有任何的类成分，是一个空类，但这个 Java 程序是绝对正确的，如果使用 javac命令来编译这个程序，就知道这个程序可以通过编译，没有任何问题。但如果使用 java 命令来运行上面的 Test 类，则会得到如下错误提示：错误：在类 Test 中找不到 main 方法，请将 main 方法定义为：上面的错误提示仅仅表明：这个类不能被 java命令解释执行，并不表示这个类是错误的。

---

• >>由于我有·C++基础，Java 基础前面的知识很容易掌握，前面的知识和C++差不不多。
• >>>数据类型与运算符：

1.注释：

• 单行注释：用双斜线 //
• 多行注释：使用“/*”和“*/”将程序中需要注释的内容包含起来-->" /*.......*/"
• 文档注释

2.标识符与关键字

>>2.1 分隔符：

；、{}、[]、()、空格、圆点（.）都是具有特殊的分割作用，被统称为分隔符。

2-1.分号
Java 语言里对语句的分隔不是使用回车来完成的，Java 语言采用分号（;）作为语句的分隔，因此每个Java 语句必须使用分号作为结尾。Java 程序允许一行书写多个语句，每个语句之间以分号隔开即可；一个调句也可以跨多行，只要在最后结束的地方使用分号结束即可。

2-2.花括号
花括号的作用就是定义一个代码块，一个代码块指的就是“{”和“}”所包含的一段代码，代码块在逻辑上是一个整体。对 Java 语言而言，类定义部分必须放在一个代码块里，方法体部分也必须放在一个代码块里。除此之外，条件语句中的条件执行体和循环语句中的循环体通常也放在代码块里。花括号一般是成对出现的，有一个“{”则必然有一个“}”，反之亦然。
2-3.方括号
方括号的主要作用是用于访问数组元素，方括号通常紧跟数组变量名，而方括号里指定希望访问的数组元素的索引。

2-4.空格
Java 语言使用空格分隔一条语句的不同部分。Java 语言是一门格式自由的语言，所以空格几乎可以出现在 Java 程序的任何地方，也可以出现任意多个空格，但不要使用空格把一个变量名隔开成两个，这将导致程序出错。
Java 语言中的空格包含空格符（Space)、制表符（Tab）和回车（Enter）等。
除此之外，Java 源程序还会使用空格来合理缩进 Java 代码，从而提供更好的可读性。
2-5.圆点
圆点（.）通常用作类/对象和它的成员（包括成员变量、方法和内部类）之间的分隔符，表明调用某个类或某个实例的指定成员。
>> 2.2 标识符规则
标识符就是用于给程序中变量、类、方法命名的符号。Java 语言的标识符必须以字母、下画线（_）、美元符（S）开头，后面可以跟任意数目的字母、数字、下画线（）和美元符（S)。此处的字母并不局限于26个英文字母，而且可以包含中文字符、日文字符等。
由于 Java 语言支持 Unicode 6.2.0 字符集，因此 Java 的标识符可以使用 Unicode 6.0.0 所能表示的多种语言的字符。Java 语言是区分大小写的，如： abc 和 Abc 是两个不同的标识符。

2.3Java关键字

Java所以的关键字都是小写的，TRUE,FALSE,NULL都不是Java关键字。

Java一共有50歌关键字:

3.基本数据类型

以下为Java的基本数据类型:

说明：如果使用的整数值超过int的范围，想让这个数由long处理，应在数值后加英文字母l或L为后缀。

>>>Jeva 中整数值有 4 种表示方式：十进制、二进制、八进制和十六进制，其中二进制的整数以 0b或 0B 开头。八进制的整数以 0 开头；十六进制的整数以 0x 或者 0X 开头，其中 10-15分别以a-f（此处的 a-f不区分大小写)来表示。
 

4.基本类型的转换

4-1自动类型转换：

• Java 所有的数值型变量可以相互转换，如果系统支持把某种基本类型的值直接赋给另一种基本类型的变量,则这种方式被称为自动类型转换。当把一个表数范围小的数值或变量直接赋给一个表数范围大的变量时,系统将可以进行自动类型转换；否则就需要强制转换。
• 表数范围小的可以向表数范围大的进行自动类型转换，就如同有两瓶水，当把小瓶里的水倒入大瓶中时不会有任何问题。
• +不仅可以作为加法运算符，还可以作为字符串连接运算符使用。

例:

//该语句将输出7hello!

System.out.println(3+4+"hello!");

• 强制类型转换语法:(targetType)value。
• 表达式类型的自动提升:

>当一个算术表达式中包含多个基本类型的值时，整个算术表达式的数据类型将发生自动提升。Java定义了如下的自动提升规则:

• >所有的 byte 类型、short 类型和 char 类型将被提升到int类型.
• 整个算术表达式的数据类型自动提升到与表达式中最高等级操作数同样的类型。操作数的等级排列。

5.运算符

• 和C++语法差不多。重点是:+和/
• +不仅可以作为加法运算符，还可以作为字符串连接运算符使用。
• /：除法运算符。如果除法运算符的两个操作数都是整数类型，则计算结果也是整数，就是自然除法的结果截断取整。例如 19/4的结果是4，而不是5：如果除法远算符的两个操作数都是整数类型，则除数不可以是0，否则将引发除以零异常。
• 但如果除法运算符的两个操作数有一个是浮点数，或者两个都是浮点数，则计算结果也是浮点数，这个结果就是自然除法的结果。而且此时允许除数是0，或者 0.0，得到结果是正无穷大或负无穷大。
• 三目运算符:

语法:(expression)? if-true-statement ： if-false-statement；

三目运算符的规则是：先对逻辑表达式 expression 求值，如果逻辑表达式返回 tnue，则返回第二个数的值，如果逻辑表达式返回 false，则返回第三个操作数的值。

• 运算符优先级问题:

6.流程控制与数组

分支结构:

• if语句和switch语句.

循环结构:

• while、do while、for循环语句.

---

switch语句Java新学:

• 新加了:允许switch语句的控制表达式是java.lang.String类型的变量或表达式——只能是java.lang.String类型。

例如：

public class stringswitchrest

{

public static void main(string[] args){

//声明变量 season

String season ="夏天"；

// 执行 switch 分支语句

switch (season）

{

case "春天":

System.out.println("春暖花开.");

break;

case"夏天":

System.out.println("夏日炎炎.")

break;

case "秋天":

System.out.println("秋高气爽.");

break;

case "冬天":

System.out println("冬雪皑皑.");

break；

default:

System.out.println("季节输入错误");

    }

  }

}

break:

break用于完全结束一个循环，跳出循环体。

• break 语句不仅可以结束其所在的循环,还可以直接结束其外层循环。此时需要在 break后紧跟一个标签,这个标签用于标识一个外层循环。
• Java 中的标签就是一个紧跟着英文鼠号（:）的标识符。与其他语言不同的是，Java 中的标签只有放在循环语句之前才有作用。
• 例如：

public class BreakTest2
{
     public static void main(String[] args)
      {
       //外层循坏，outer作为标识符
       outer:
             for(int i=0;i<5;i++)
                {
                    //内层循坏
                    for（int j=0;j<3;j++）
                     {
                          System.out.println("i的值为： " + i + "j的值为：" + j);
                          if(j==1)
                           { 
                              //跳出outer标签所标识的循环
                              break outer;
                           }
                     }
                } 
       }
}

 运行上面的程序，结果为：

i的值为：0    j的值为：0

i的值为：0     0j的值为：1

•  程序从外层循环进入内层循环后，当j 等于 1 时，程序遇到一个 break outer;语句，这行代码将会导致结束 outer 标签指定的循环，不是结束 break 所在的循环，而是结束 break 循环的外层循环。所以看到上面的运行结果。
  值得指出的是，break 后的标签必须是一个有效的标签，即这个标签必须在 break 语句所在的循环之前定义，或者在其所在循环的外层循环之前定义。当然，如果把这个标签放在 break 语句所在的循环之前定义，也就失去了标签的意义，因为 break 默认就是结束其所在的循环。

注意： 通常紧跟break之后的标签，必须在break所在循环之前定义才有意义！

--使用 continue忽略本次循环剩下语句：

• 忽略本次循环，接着开始下一次循环，并不会终止循环。
• continue后面也可紧跟一个标签，用于直接跳过标签所标识循环的当次循环的剩下语句，重新开始下一次循环。
• 例如： 

public class Welcome {
	public static void main(String[] args)
	{
	//外层循环
	outer:
		for(int i=0;i<5;i++)
		{
			//内层循坏
			for(int j=0;j<3;j++)
			{
				System.out.println("i的值为： " + i +"j的值为：" + j);
				if(j==1)
				{
					//忽略outer标签所指定的循环中本次循环所剩下语句
					continue outer;
				}
			}
		}
	}
}

--使用return结束方法： 

•  
  retum 关键字并不是专门用于结束循环的，retum 的功能是结束一个方法。当一个方法执行到一个 retun语句时（retum 关键字后还可以跟变量、常量和表达式，这将在方法介绍中有更详细的解释)，这个方法将被结束。
  Java程序中大部分循环都被放在方法中执行，一旦在循环体内执行到一个 return 语句，return 语句就会结束该方法，循环自然也随之结束。

例如： 

public class Welcome {
	public static void main(String[] args)
	{
		for(int i=0;i<3;i++)
		{
			System.out.println("i的值为："+ i);
			if(i==1)
		    {
	          return;
			}
			System.out.println("reurn 后的输出语句");
		}
	}
}

---

 --数组类型：

• .定义数组： 

 两种格式：

 tepe[] arrayname;

 type   arrayname[];

引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量（也就是定义了一个指针)，这个引用变量还未指向任何有效的内存，因此定义数组时不能指定数组的长度。而且由于定义数组只是定义了一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有对数组进行初始化后才可以使用。

• 注意：定义数组是不能指定数组的长度 
•  数组的初始化：1.静态初始化；2.动态初始化.

1)静态初始化语法：

arrayName=new type[] {element1,element2,element3,......} 

type 为数组元素的数据类型，值得指出的是，执行静态初始化时，显式指定的数组元素值的类型必须与 new 关键字后的 type 类型相同，或者是其子类的实例。

 静态初始化简化格式：

type[] arrayName={element1,element2,.....}

2)动态初始化：

只指定数组的长度，又系统为每个数组元素指定初始值。

语法格式：

 arrayName=new type[length];

 //数组的定义和初始化同时完成，使用动态初始化语法：

int[] prices = new int[5];
//数组的定义和初始化同时完成，初始化数组时元素的类型是定义数组时元素类型的子类：
Object[] books = new String[4]；
--执行动态初始化时，程序员只需指定数组的长度，即为每个数组元素指定所需的内存空间，系统将负责为这些数组元素分配初始值。指定初始值时，系统按如下规则分配初始值。
数组元素的类型是基本类型中的整数类型（byte、short、int 和 long)，则数组元素的值是 0.
数组元素的类型是基本类型中的浮点类型（float、double)，则数组元素的值是 0.0。
数组元素的类型是基本类型中的字符类型（char)，则数组元素的值是\u0000。
数组元素的类型是基本类型中的布尔类型（boolean)，则数组元素的值是 false。
数组元素的类型是引用类型（类、接口和数组)，则数组元素的值是 null.

数组遍历：

public static void main(String[] args) {

int[] x = { 1, 2, 3 };

for (int y = 0; y < 3; y++) {

System.out.println(x[y]);

// System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

} 

}
————————————————

 数组中有一个属性可以获取到数组中元素的个数,也就是数组的长度. 数组名.length：

public static void main(String[] args) {

int[] x = { 1, 2, 3 };

for (int y = 0; y < x.length; y++) {

System.out.println(x[y]);

} 

}

---

 

数组的常见异常

数组中最常见的问题：

1. NullPointerException 空指针异常
原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

2. ArrayIndexOutOfBoundsException 索引值越界。
原因：访问了不存在的索引值。

一数组角标越界异常:，注意：数组的角标从0开始。

public static void main(String[] args) {

int[] x = { 1, 2, 3 };

System.out.println(x[3]);

//java.lang.ArrayIndexOutOfBoundsException

}

二维数组： Arrays的使用

遍历： toString()    将数组的元素以字符串的形式返回

排序： sort()        将数组按照升序排列

查找： binarySearch()在指定数组中查找指定元素，返回元素的索引，如果没有找到返回（-插入点-1） 注意：使用查找的功能的时候，数组一定要先排序。

 >>二维数组：实质就是存储是一维数组。

数组定义：

       数组类型[][] 数组名 = new 数组类型[一维数组的个数][每一个一维数组中元素的个数];

数组的初始化：

静态初始化:

int [][] a = new int[][]{ {12,34,45,89},{34,56,78,10},{1,3,6,4} };

动态初始化:

---

 ----for each循环：

语法格式：

for(type variableName : array | collection)
{
  //variableName 自动迭代访问每个元素......
}
//type 是数组元素或集合元素的类型，variableName 是形参名

 注意：for each 循环迭代数组元素时，并不能改变数组元素的值，因此不要对for each 的循环变量进行赋值。