黑马程序员--Java基础之编程基础

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！


Java编程基础整理（本文是由小妞纯手工整理哦，包含了各种注意点、重点还有各种坑）

一、关键字，标识符，注释

关键字（掌握）51+2个
注意：main不是关键字
关键字都是小写
两个保留字：goto，const


标识符（掌握）
由26个英文字母大小写，数字0-9，符号 _ $ 组成
注意：1.数字不可以开头
     2.不可以使用关键字
Java严格区分大小写
命名规范：
    A:包
包名：xxxyyyzzz
全部小写。如果是多级包，用.分开。
举例：itcast
cn.itcast
com.baidu
给某个公司做项目：域名反写作为包名。
B:类和接口（见名知意，驼峰命名）
   类名接口名：XxxYyyZzz
a:如果类名是一个单词，这个单词的首字母大写。
举例：Student
Teacher
b:如果类名是由多个单词组成，每个单词的首字母大写。
举例：HelloWorld
LinQingXia
C:方法和变量
   变量名和函数名：xxxYyyZzz
a:如果是一个单词，这个单词的首字母小写。
举例：main()
age
b:如果是多个单词组成，从第二个单词开始，每个单词的首字母大写。
举例：showName()
studentAge
D:常量
   常量名：XXX_YYY_ZZZ
a:如果是一个单词，全部大写。
举例：PI
b:如果是多个单词，全部大写，并用_隔开
举例：STUDENT_MAX_AGE


注释
注意事项：单行注释里面可以有单行注释，多行注释里面也可以有单行注释
 但是多行注释里面不能有多行注释
注释的作用：一对程序进行解释说明，二调试程序，这行有问题，把它注释掉

/**文档注释*/
/*多行注释*/
//单行注释

二、数据类型

（一）常量

常量(掌握)
(1)在程序运行过程中其值不发生改变的量。
(2)定义分类：
字面值常量
自定义常量(后面讲)
(3)常量的分类：
整数常量 12,-34
小数常量 12.5
布尔常量 true,false
字符常量 'a','A','0'
字符串常量 "hello",""
空常量 null

（二）进制

八进制：用0开头表示
十六进制：用0x开头表示
二进制：0b(JDk7之后出现)

二进制和十进制之间的转换：
十进制——>二进制：原理：对十进制进行除二运算
Integer.toBinaryString()
二进制——>十进制:原理：二进制乘以2的过程

其他进制转换：
转成十六进制：四个二进制位就是一个十六进制位
转成八进制：三个二进制位就是一个八进制位


负数的二进制表现形式：
6=110
-6：其实就是6的二进制取反+1
负数的最高位都是1


原码、反码、补码：
 正数：正数的原码，反码，补码都一致。 
 负数：负数的原码和正数的区别是最高位是1。表示符号位。
举例: +7 ->0 0000111
-7 ->1 0000111
负数的反码和负数的原码的区别是：符号位不变，数值位1变0,0变1。
举例: +7 ->0 0000111
-7 ->1 1111000
负数的补码是负数的反码+1。
举例: +7 ->0 0000111
-7 ->1 1111001
特别注意：任何数据在计算机中都是以补码的形式存储的。

（三）变量、数据类型

变量：就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间
如何开辟空间呢？就是通过明确数据类型，变量名称，数据来完成


    |---数值型--|---  整数类型 （   byte    short      int      long）(默认int)
|--- 基本数据类型    |          |             8个二进制位 16个二进制位  4个8位    64位
|    4类8种         |          |                  -128~127
|                   |          |
|                   |          |---  浮点类型(float      double)（默认double）
|                   | 32位       64位
|                   |                       7~8位有效数字  15~16位有效数字
数据类型—|                   |---字符型(char)16个二进制位(2个字节)
|                   |
|                   |---布尔型(boolean)不明确 1个字节
|
|                   |---类(class)
|---  引用数据类型---|   接口(interface)
    |---数组([])


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


byte b = 128;//错误：可能损失精度（因为byte范围为-128~127）
lang l = 4l;
float f = 2.3;//错误：可能损失精度（double类型的值赋给了float）                             
float f = 2.3f;//表明是单精度
char ch = '4';//单引号标识 占两个八位


注意：
整数默认是int类型。long类型需要加L或者l后缀。

浮点数默认是double类型。float类型需要加F或者f后缀。

（面试题）：
byte b1 = 126;

int i = 180;
byte b2 = (byte)i;

int i2 = 300;
byte b3 = (byte)i2;


System.out.println(b1);//126
System.out.println(b2);//-76
System.out.println(b3);//44


解释：180在内存中的存储为00000000 00000000 00000000 10110100(补码)
可以得到反码：00000000 00000000 00000000 10110011
原码： 00000000 00000000 00000000 11001100
由于byte类型在内存中占一个字节，所以只截取最后8位，即：11001100
转换为十进制为：-76


300在内存中的存储为：00000000 00000000 00000001 00101100(补码)
原码也为：00000000 00000000 00000001 00101100
截取最后8位：00101100


什么时候定义变量？
当数据不确定时，需要对数据进行存储时，就定义一个变量来完成存储动作


关于字符串的一个应用：eg  1+2+"java"+3+4 ===>结果是3java34，即字符串之前的参与运算，字符串后面的则按字符串输出（把后面的默认强转为字符串了）。这里的+是连接符，也就是说这个的最后结果一定是一个字符串，只不过区别在于有没有进行数值之间的运算而已
==>常用的一个操作：int类型转换为String类型：
int num = 100；
String s = num + "";//这时num就变成字符串类型的100了。


记住三个ASCII码:
 'a':97   'A':65   '0':48  通过这三个可以推出所有英文大小写字母和数字的ASCII码(事实上，可以直接调用'a''A''0',在同类型比较时，系统自动将其转换为ASCII码)。
eg.public class TongJiZiFu {
public static void main(String[] args) {
String str = "Hello12345World";
int bigCount = 0;
int smallCount = 0;
int numCount = 0;
for(int i =0;i<str.length();i++){
char ch = str.charAt(i);
if(ch>='a'&&ch<='z'){
smallCount++;
}else if(ch>='A'&&ch<='Z'){
bigCount++;
}else if(ch>='0'&&ch<='9'){
numCount++;
}
}
System.out.println(bigCount+","+smallCount+","+numCount);
}
}
注意：'a'+1与"a"+1是不一样的，前者+为运算符结果为98，后者+为连接符，连接字符串和数字。

（四）类型转换

类型转换：隐式转换：byte，short->
char->int->long->float->double，表示范围依次增大，小到大可以隐式转换。
(主要是对常量，当然前提是在表示范围以内)
隐式转换（自动类型转换）：
byte b = 3;
int x = b;//程序把byte类型的变量b转换成了int类型，无需特殊声明


byte b = 3;
b = b + 2;
//会报错:因为2 默认类型是int，占4个8位，而byte本来占一个8为，会自动升级，两个都变成4个8位，结果就是4个8位的，赋值给byte类型的b就会报错
可以进行强制转换：b = (byte)(b+2);
特殊：
char ch = 'a';//结果为 a 
ch = ch + 1;//结果为98 发生了类型提升。'0'在ASCII表中是48


char类型的可以放一个汉字，因为一个汉字两个字节


int x=y=z=5;//这样写是错误的

int x = 3;
//+= -= *= /= %=使用这些符号时，强制类型转换会自动完成
x+=4;//x = x + 4;

面试题：
short s = 4;
s = s + 5;//编译失败，涉及到类型转换
s+=5;//编译成功，自动强转

例（面试题）：
  byte a=3;
  byte b=4;
  byte c=a+b;
  byte d=3+4;//不会报错，因为参与运算的是常量，编译器会先计算值，再看该值是否是左边能够表示的范围。如果是，就不报错。


这个byte c=a+b;是要报错的，因为a+b在计算的时候是默认转换成int型计算的（byte，short，char类型的变量计算时皆会提升为int，而其它类型则按它们自己的类型计算），结果也是int型，此时应对a+b进行byte强制转换。
另：在强制转换时应对int用（）括起来，不然报错！

Test：
给定java代码，如下：
public byte count(byte b1, byte b2){
return ____;
}
要使这段代码能够编译成功，横线处可以填入  A
A. (byte)(b1-b2)
B.   b1-b2        不对
C.  (byte)b1+b2
D.  (byte)b1/b2//只强转了b1


Test：
1. 下列方法定义中，正确的是(  CD )。 
A) int x( ){ return true; } 
B) void x( ){ return true; } 
C) int x( ){ char ch='a'; return (int)ch; }//这里不强转也可以，
D) int x( int a, int b){ return a+b; }

二、运算符

（一）算术运算符

除 /
只取整数
int x = 4270;
x = x /1000 * 1000;//结果是4000
整数相除，结果只能是整数；如果想要小数，那么参与运算的数据必须有一个是浮点数类型。
例：float d=5/2.0f，则d为2.5
  而int d= 5/2,则d为2.


取模：%
1%5   //结果1
1%-5  //结果1
-1%5  //结果-1， 正负只看左边


int a = 3,b;
//a++; //--> a = a + 1;
b = ++a;//先吃饭再出去玩,a++先出去玩再吃饭


练习：
1.++：
 例：A. int x=2；x=（x++）/3,结果为0.先从括号中取出x参与后面的运算。
int x=2；x=（++x）/3，结果为1。先自加，后出括号参与运算。


B.若a,b为int型变量且已分别赋值为2，6。表达式(a++)+(++b) +a*b的值是__30___ 。
注：2+7+3*7
注意以上两个题的区别，A中x出了括号有/运算，这个优先级比自增++要高，所以先参加/运算。
    而B中x出了括号之后没有更高级运算，所以又退回括号自增。
2.另外一种类型的应用：
eg.（蓝色为对）
1）下面程序执行的结果是？（）
int i = 100;
while(true)
{
if (i++ > 100)   //i先进行判断，再自加，然后输出！
{
break;
}
System.out.println(i);
}
A.  100
B.  101
C.  102
D.  报错
2）下面程序的运行后,结果正确的是：
int a=1,b=2;
int c=(a+b>3?a++:++b); //a没有被运行到，所以没有进行运算。
A.  a=2,b=3
B.  a=1,b=3
C.  a=1,b=2
D.  c=2
3） 下面程序执行的结果是？（ ）
int x =1,y=1;
if(x++==2 & ++y==2) //这里x参加了运算！
{
x=7;
}
System.out.println("x="+x+"  ,  y="+y);
A.  x=1  y=2 
B.  x=7  y=1 
C.  x=7  y=2  
D.  x=2  y=2




字符串和任何数据使用+都是相连接，最终都会变成字符串
System.out.println("ab"+(5+5));//ab55
System.out.println("5+5="+(5+5));//5+5=55

（二）比较运算符

比较运算符，常用在if语句中：
A.用于比较基本数据类型的时候：
比较的是两个基本类型的值是否相同；
B.用于比较引用型数据类型的时候：
比较的是两个引用类型数据的地址值是否相同。
eg.
public class StudentTest2 
{
public static void main(String[] args) 
{
int x =10;
int y =10;
System.out.println(x==y);//true

Student s1 = new Student();
Student s2 = new Student();
Student s3 = s1;
System.out.println(s1==s2);//false
System.out.println(s1==s3);//true
}
}

（三）逻辑运算符

&和&&：
&：无论左边是true还是false，右边都运算
&&:当左边为false时，右边不运算


可举例：
int a = 4; int a = 4;
int b = 3; int b = 3;
boolean bool = a++<7 & b++>3; boolean bool = a++<7 && b++>3;
System.out.println(a);//5 System.out.println(a);//5
System.out.println(b);//4 System.out.println(b);//3
|和||：
|：两边都参与运算
||：当左边为true，右边不运算

（四）位运算符

>>：最高位补什么由原数据的最高位值而定
   如果最高位0，右移后，用0补空位。
   如果最高位1，右移后，用1补空位。
>>>;无论最高位是什么，右移后，都用0补


恶心题：
设以下是应用程序中定义的方法printBinary，若在其main方法中有方法调用语句printBinary(2)，则输出的结果是 (  B )。
static void printBinary(int i) {
System.out.print(i + "的2进制数表示为：t");//2的2进制表示为：
for(int j = 31; j >=0; j--)         
   if(((1 << j) &  i) != 0)
System.out.print("1");
   else
System.out.print("0");
System.out.println();
 }
A) 00000000000000000000000000000001
B) 00000000000000000000000000000010
C) 00000000000000000000000000001111
D) 00000000000000000000000000000000

面试题位运算练习：
1.最高效的算出2*8等于几   2<<3


2.对两个整数变量的值进行互换（不需要第三方变量）
11=3+8；   n =n+m;//如果n和m的值非常大，容易超出int范围
3=11-8；   m =n-m;
8=11-3；   n =n-m;

（五）条件运算符

三元运算符

int x = 100;
int y = 200;
int z = (x>y)?(x>100?3:5):(y<500?35:90);//加括号呀加括号

三、if和Switch

if 
三种格式： if  if-else  if-else if-else

（Demo：获取两个数中的最大值）

注意事项
a:什么时候时候哪一种if语句。
第一种格式在判断条件为一种情况下使用。
第二种格式在判断条件为两种情况下使用。
第三种格式在判断条件为多种情况下使用。
b:每一种if语句其实都是一个整体，如果有地方执行了，
 其他的就不执行了。
c:如果if或者else里面控制的语句体是一条语句，是可以省略大括号的，
 但是，如果是控制多条语句，就必须写上大括号。
 建议：永远写上大括号。
d:大括号和分号一般不同时出现。
注意：
int x = 10;
if(x<5);
System.out.println("哎呀");
System.out.println("嗯嗯额");

执行结果为：哎呀
   嗯嗯额


（Demo A:根据键盘录入的成绩，判断等级。(代码：IfTest2.java)
B:根据键盘录入的月份，输出该月份所对应的季节。）(代码：IfTest3.java)

Scanner的使用(掌握)
(1)Scanner是JDK5以后设计的用来接收键盘录入数据使用的。
(2)目前我们要通过键盘录入int类型数据,必须按照如下步骤：
A:导包
import java.util.Scanner;
B:创建对象,封装键盘录入
Scanner sc = new Scanner(System.in);
C:调用方法,获取数据
int number = sc.nextInt();


if else 结构简写格式：  变量 = （条件表达式）？表达式1：表达式2；
三元运算符：好处：可以简化if else 代码
   弊端：因为是一个运算符，所以运算完必须要有一个结果
if...else语句是流程控制语句,执行后不一定有结果,可以是输出语句.而三元运算符不可以输出语句.


if 和switch：
二者很像，具体什么场景下应该用那个语句呢？
如果判断的具体数值不多， 而是符号byte short int char这四种类型（只支持这四种类型，一般为int char）
JDK5以后可以是枚举类型。 JDK7以后可以是String类型
面试题。switch语句后面的表达式可以是byte吗?可以是long吗?可以是String吗?
值x:用于和表达式进行匹配的值。

虽然两个语句都可以使用，建议使用switch语句，因为效率稍高
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广


class SwitchDemo 
{
public static void main(String[] args) 
{
int x = 3;


switch (x)
{
default:
System.out.println("d");
   break; //case和default语句可以任意交换位置排列
   Switch结束有两种方式：执行到break或者大括号
   default语句中的break; 可以省略掉。但是在这种排列情况下，如果把break省略掉，当x的值与任何case都不匹配时，会在执行完
   default的语句后继续往下执行任何可执行语句，知道遇到break;
case 4:
System.out.println("d");
   break;
case 6:
System.out.println("a");
   break;
case 2:
System.out.println("c");
   break;

}
}
}
//有Case先找Case，找到之后按顺序执行
//没Case找default，找到default之后按顺序执行


注意事项：
A:default可以省略吗?可以。
 但是，一般不省略，它相当于if的else语句，可以控制所有的非正常情况。
 假如你非常明确可以省略，那就省略。
B:break可以省略吗?
放在最后面的default的break是可以省略的。
放在case语句中的break是可以省略的，但是可能结果有问题。
所以，一般不省略。
C:default可以不放在最后面吗?
可以，但是一般都放在最后面。
D:switch语句什么时候结束吗?
遇到break或者执行到switch语句的末尾。
（Demo：A:根据键盘录入的日期(1-7),输出对应的星期日期。（代码：SwitchDemo.java）
B:根据键盘录入的月份，输出该月份所对应的季节。(选做)）

例：
下面程序执行的结果是？（ ）
boolean b=true;
if(b=false) //注意，这里是一个赋值运算！把b的值从true变为了false，对下面的判断产生影响！！不是条件判断（应为b==false）！
{
System.out.println("a");
}
else if(b)
{
System.out.println("b");
}
else if(!b)
{
System.out.println("c");
}
else
{
System.out.println("d");
}
A. a   
B. b  
C. c
D. d

四、循环

（一）for和while

什么时候定义变量：当你知道这是一个变化的内容的时候。
一般定义的范围：
首先是在小范围内，如果不合理，在考虑大范围...


1.变量有自己的作用域。对for来讲，如果将用于控制循环的增量定义在for语句中。那么该变量只在for语句内有效。for语句执行完毕，该变量在内存中被释放。


定义在for循环中的变量，在循环之外是不能用的。


2.for和while是可以等价转换的，但是：
二者区别：
for：初始化条件的变量在for循环结束后不可再用（因为它的条件变量是局部变量，定义在循环内部）；
while：初始化条件的变量在while循环结束后仍可再用（因为它的条件变量是成员变量，定义在循环外部）；

如果这个变量仅仅是控制次数，建议用for，因为for循环结束，变量就结束而被回收，效率更高。
3. 什么时候用for或者while？
如果控制范围明确，最好用for；
如果范围不明确，用while。如吃橘子，吃葡萄等等问题，问题的规模不明确，用完为止。


4.while（true）{}表示永远循环下去，直到运行里面的break或者其他中断条件；所以在使用这个是时候一定要慎重，将里面的各种情况考虑清楚再写

总结：
什么时候使用循环结构？
当要对某些语句执行很多次时，就使用循环结构。


Test：
以下语句有语法错的是：（A ）
A．int x=1; y=2; z=3 分号
B．for (int x=10,y=0; x>0; x++);
C．while (x>5);
D．for(; ;);


Test：
for循环格式如下：
for(表达式1;表达式2;表达式3){
//code
}
下面描述错误的是（ACD）
A.  表达式1处的代码会被执行多次
B.  表达式1处可以定义变量
C.  表达式3用于决定循环是否应该结束
D.  表达式2的值可以是任意类型，也可以是boolean类型     //只能是boolean

求1-100奇数或者偶数和：
for (int x =0; x<=100;x+=2){ sum=sum+x;}//记住


for (int x =1; x<=100;x+=2){ sum=sum+x;}//记住

（二）while和do-while

while:先判断条件，只有条件满足才执行循环体
do while：先执行循环体，再判断条件，条件满足，再继续执行循环体。
简单来说：do while无论条件是否满足，循环体至少执行一次

（三）for 嵌套

无限循环的最简单表现形式
for(;;){}

while(true){}


循环嵌套
1.练习：打印形状
/*
打印如下图形
*
**
***
****
*****
思路：利用嵌套循环：外层循环控制行数，内循环控制列数。

不是规律的规律：
尖朝上，可以改变条件。让条件随着外循环变化。
尖朝下，可以改变初始化值，让初始化值随着外循环变化。
*/


class ForFor 
{
public static void main(String[] args) 
{
//尖朝上
int k=1;
for (int i=0;i<5 ;i++ )
{
for (int j=0;j<k ;j++ )
{
System.out.print("*");

}
System.out.println();
k++;
}
System.out.println("----------------------------------------");



//尖朝下 1
int m=0;
for (int i=0;i<5 ;i++ )
{
for (int j=m;j<5 ;j++ )
{
System.out.print("*");

}
System.out.println();
m++;
}
System.out.println("----------------------------------------");


//尖朝下 2


for (int i=0;i<5 ;i++ )
{
for (int j=i;j<5 ;j++ )
{
System.out.print("*");

}
System.out.println();

}
System.out.println("----------------------------------------");

/*
打印
1
12
123
1234
12345
*/
for (int i=1;i<5 ;i++ )
{
for (int j=1; j<=i;j++ )
{
System.out.print(j);
}
System.out.println();
}
System.out.println("----------------------------------------");


/*
打印九九乘法表：面试题
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
*/
for (int i=1;i<=9 ;i++ )
{
for (int j=1;j<=i ;j++ )
{
System.out.print(j+ "*" + i + "=" +j*i+"t");//制表符t，如果用空格会不整齐
}
System.out.println();
}
}
}


转义字符：通过 来转变后面字母或者符号的含义
n:换行
b:退格。相当于backspace
r：按下回车键。Windows系统，回车符是由两个字符来表示rn
t:制表符。相当于tab键


3.输出 n=6 的三角数字阵
1
2  3  
4  5  6
7  8  9  10
11 12 13 14 15
16 17 18 19 20 21


4.请输出满足这样条件的五位数。
个位=万位
十位=千位
个位+十位+千位+万位=百位
怎么获取各位的值：个位：x%10
十位：x/10%10
百位：x/10/10%10

5.（拔高选做题，如果你把之前所有的知识都掌握了，可以思考一下这道题，本题不要求必须完成）
输出 n=5 的螺旋方阵
1  2  3  4  5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9 

（四）break-continue

break（跳出）语句：应用于选择结构和循环结构。跳出循环语句，执行后面的代码
continue（继续）语句：应用于循环结构。结束本次循环，继续下一次循环
注：break和continue单独存在时，下面可以有任何语句，因为都执行不到

带标号的结束：
除了使用常规break，continue的方法之外，还可以使用带标号的结束。
例：
WC:for(int x = 0;x<5;x++)
{

for(int y=x;y<5;y++)
{
System.out.print("*");
break WC;
}
System.out.println();
}

五、函数：定义在类中，有特定功能的一段小程序。

1.写函数，先定返回值类型，再定参数个数与类型。


 定义函数时要注意（函数特点）：
函数与函数是平级的，不能嵌套定义。
函数只有被调用才能执行。


2.定义方法参数的原则：函数内部无法确定的要通过参数传递。


3.函数如果有返回值类型，则必须有返回语句，否则报错（void可以不用写，会默认有一个return）。


4.函数功能尽量单一，不要集成输出等功能，直接返回值就行。这样利于函数的充分利用。


5.实际开发中，功能一个一个的写，写完一个，编译调试一个，以便查找修改错误，否则错误太多，不易修改。


6.函数的调用：
A:有明确返回值
a:单独调用 一般没有意义。
举例: sum(2,3);//直接调用计算2+3的和.
b:输出调用 但是如果想拿结果继续操作，就有问题了。所以，不好。
举例: System.out.println(sum(2,3));
c:赋值调用 推荐方式。
举例: int c = sum(2,3); //把计算结果赋值给c 


B:void类型
单独调用, 把结果直接打印在控制台上.


7.函数由return语句让它结束，而不是}或者别的。
 注意，void返回值类型return；不是返回空，空是有意义的，而这里是什么都不返回，只有一个默认存在的return；


Test：
下面关于return语句说法正确的是：??（?C?）?
A．只能让方法返回数值? 数值？？！！！  怎么可能
B．方法都必须显式使用该关键字?错
C．方法中可以有多句return?
D．不能用来返回数值以外的类型



8.重载的方法之间也可以相互调用，重载是指函数名字相同，参数个数或者参数类型不同，与返回值没关系！
重载的概念；
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。


方法的重载与返回值类型无关，只需要满足两个条件：一是方法名相同，二是参数个数或者参数类型不同


9.函数重载：参数传递进来之后，先找参数完全符合的函数，如果没有，则找相近的，如可以自动转换类型的。
 注意：工作中不可这么做！
Test：
类中某方法定义如下：
double?fun(int?a,int?b){???
return?a*1.0/b;??
}?
同一类内其它方法调用该方法的正确方式是：?A    
A. double?a?=?fun(1,2);?
B.  double?a?=?fun(1.0,2.0);?
C.  int?x?=?fun(1,2);??
D.  int?x?=?fun(1.0,2.0);
//如果传进来的是两个byte类型的数，也可以，会自动转换


Test：
下面关于函数描述正确的是（AD） 
A.  函数是对功能代码块的封装
B.  函数没有返回值的时候不用写返回值类型    不对！！！！！
C.  没有返回值的函数，不能有return 语句 错
D.  函数是可以没有形参的

六、数组

（一）数组

数组：数组是存储同一种类型的多个元素的容器。

堆的特点：
1.内存地址值
2.默认初始化值
3.垃圾回收机制

栈：
自动释放

ArrayIndexOutOfBoundsException:操作数组时访问到了数组中不存在的角标
NullPointerException：空指针异常：当引用没有任何指向值为null的情况，该引用还在用于操作实体。


数组长度：
数组名.length

注意！！！
char类型的数组打印其数组名，结果是数组中的内容；
 其它诸如int类型的数组打印其数组名，结果是数组地址值；
eg.public class Test {
public static void main(String[] args) {
char[] ch = {'a','b','c'};
int [] num ={1,2,3};
String[] str ={"ab"};
System.out.println(ch);
System.out.println(num);
System.out.println(str);
}
}
运行结果：abc
   [I@1b8d6f7
   [Ljava.lang.String;@290fbc

（二）一维数组

一维数组：
1.格式：
A:int[] arr = new int[3];  //只定义了数组的长度
B:int arr[] = new int[3];  //不建议使用
C:int[] arr = new int[]{1,2,3};  //定义了数组的内容,但是格式麻烦，
  //注意int[] arr = new int[3]{1,2,3};这种方式错误的！
D:int[] arr = {1,2,3}; //定义了数组的内容, 省事, 建议使用.


另一种类型：int [] arr={‘a’, 23 , 45 , 6}；是正确的，因为char类型的'a'可以自动转换为int型！！！

老程序猿推荐: A和D。
2.int类型数组初始值都为0.


Test：
下面数组定义正确的是（A）
A.  int [] arr ={23,45,65,78,89};
B.  int [] arr=new int[10]{};
C.  int [] arr=new int[4]{3,4,5,6};
D.  int [] arr={"a",23 ,45,6};//’a’可以自动转成int，但“a”不可以


Test：
阅读下面代码段：
public class Demo
{
　　public static void main (String[] args)
　　{
int[] arr = new int[10];//默认初始化值为0
　　 System.out.println(arr[1]);
　　}
}
执行结果正确的说法是( C )
A.  编译时将产生错误
B.  编译时正确，运行时将产生错误
C.  输出零

最后

以上就是英俊学姐为你收集整理的黑马程序员--Java基础之编程基础的全部内容，希望文章能够帮你解决黑马程序员--Java基础之编程基础所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。