第二章
2.1 java代码的落脚点
之前我写的是跟这本教程写的是一样的格式如下
修饰符 class 类名
{
语句；
}
但是现在改成了 ：
修饰符 class 类名{
语句；
}
这就是传说的括弧之争。
java中时严格区分大小写的，注意java语句的最后是以英文的; 而不是以中文；,这里需要注意。
java的注释：（要养成较好的注释习惯，尤其是刚入手编程的时候）
单行注释： //
多行注释： /* */
文档注释： /** */ 这个对我现在的作用还不是很明显
java的标识符：
组成是由：字母、数字、下划线、美元符号
其中标识符不能以数字开头，这点和C是一样的，同样保留关键字
java中常量：
注意：
十进制和平常的使用时一样的，但是十六进制则是以0x开头，八进制是以0开头
浮点数，有单精度和双精度之分 其中写float就要在3.12F 否则默认为double
布尔常量：只有false 和 true 两个 ，不再是C里面的0或非零
这里说一下反义字符：如果要输出\t
如：System.out.println("\t"); 这样输入System.out.println("\\t");
2.2 变量及变量的作用域
变量的概念：
程序运行时，需要系统为其分配相应的内存单元用于存储数据，而这个内存单元
则要使用一个标记符来标识，这个内存单元的所装载的数据集市变量值。
java的变量类型：
java中有8中基本的数据类型：（java和C不一样，java在不同系统所占的大小都是一样的）
byte 8 bit -128~127
short 16 bit -32768~32767
int 32 bit
long 64 bit
float 32 bit 这个后面要记得加上F 否则默认为double
double 64 bit
变量的有效范围
例如：byte 的范围是-128~127
byte b=129;
这样是会报错的！
例如：float是分配4个字节，但是下面默认为double 则需要8个字节
float f=3.2;
这样也是同样会报错的！
数据之间的转换：
1、自动类型转换（隐式转换）小->大
满足2个条件：目标类型和源类型是彼此兼容的&&目标类型的取值范围要大于源类型（否则会丢失精度的报错）
如：byte n=3; int x=b;
2、强制类型转换 大->小 能取多少取多少
不兼容||目标类型小于源类型
如：int a=1; byte b=(byte)a;
类型提升：
class Promote{
public static void main(String[] agrs){
byte b=50;
char c='a';
short s=1024;
int i=50000;
float f=5.67f;
double d=0.32;
double result=(f*b)+(i/c)-(d*s);
System.out.println((f*b)+"+"+(i/c)+"+"+(d*s));//(f*b)->float (i/c)->int (d*s)->double
System.out.println("result="+result);
}
}
向高类型转换；存在
byte short char int -> int
long -> long
float->float
double ->double
变量的作用域：
class Scope{
public static void main(String[] agrs){
int x=2;
{
int x=3;//这样是会报错的！java是不允许存在混淆的！而C++可以
int q=4;//这个的作用域就只有在这个{}中
}
System.out.println(q);//这样是会报错的！
}
}
局部变量初始化：
public Var{//其实最简单的方法就是都给它初始化，懒得去记。这是一个好习惯
//static int i;
public static void main(String[] agrs){
int i;
i=i+1;//这里会报一个没有初始化的错误，但是将static int i 放到类中则不会报错
}
}
2.3 函数与函数的重载
函数的各个部分：
[权限修饰符] 返回类型 方法名（参数1，参数2...）{语句;return ?;}
函数的重载：
在同一个类中存在2个以上方法名相同的方法，但是参数类型，或个数不同，系统会根据实际情况
调用相应的方法。但是除了返回值不同外，其他的地方都相同这也是不行的！JVM同样不能识别啊！
2.4 java 中的运算符
算术运算符： ++ --
int a=i++;//这里是把i赋给a，然后i再加1
int b=++j;//这里是把J加1 ，然后再赋给b
上面的情况同样适用于--
% ->
5%(-2)=1
(-5)%2=-1
/ ->
5/2=2
5/2.0=2.5
书中提到的2个算法
六人一个房间，需要几个房间 （x+5）/6 这儿确实很巧妙
第二是要求x的值要在0-9之间循环 是由1-9-0 刚开始以为没有说出0
import java.util.Scanner；
public class Promote{
public static void main(String[] agrs){
int x=0;
String choice;
Scanner sc=new Scanner(System.in);
do{
x=(x+1)%10;
System.out.println(x);
System.out.println("input");
choice=sc.next();
}while("Y".equalsIgnoreCase(choice));
}
}
逻辑运算符：
区分= 和 ==
^ 异或
if(true^false){
System.out.println("...");//会输出
}
if(true^true){
System.out.println("s...");//不会输出
}
&& （短路与） 和 || （短路或） ->如果在前面就能得到结果的时候，后边的那个布尔值是不会计算的
而非短路的，则会继续
位运算符：
运算符的优先级->只需要有个大概的印象就可以了，怕出错就加多个括号！Oh,yeah
2.5 程序的流程控制
顺序
选择
switch(var){ //这里var 只能是int char
case 1: 语句；break;//上面这个必须有，否则后面的就会执行下去
case 2: 语句; break;
default: break;//最后这个可以加上break也可以不要
}
循环
while(条件){}
do{}while(条件);//这里需要记得后面要加上; 这2中都是在条件成立的时候，循环
增强型for:
int[] x={1,2,3,4,5};
//输出以为数组
for(int i:x){ 冒号:后边的是 数组的地址 前面则是这个地址对应的数据类型
System.out.print(i+"\t");
}
System.out.println();
int[][] y={{1,2,3,4,5},{6,7,8,9,10}};
//输出二位数组 //这个for里边的写法需要注意
for(int[] i: y){ //这里的Y代表的是int[] 的地址
for(int j: i) //这里的i才是代表着int 的地址
System.out.print(j+"\t");
}
break 和 continue 语句
break 中断当前循环 只能跳出一层循环
continue 跳过当前循环的剩余语句
如：for(int i=0;i<12;i++){
if(i==9){
continue;//当i==9的时候，就会直接加速到i=10,不会执行下面的换行语句
}
System.out.println();
}
数组：
数组的定义：数据类型[] 数组名=new 数据类型[数组个数]
如：int[] x=new int[10] //这样就是定义了10个int型的变量
或：
int[] x;//栈内存为数组引用分配空间
x=new int[10];//在堆内存中为数组分配匹配空间
数组的查看是以下表指引的，下标是从0开始的到9
数组在堆内存空间中配的是一段连续的空间
import java.util.*;
class Array{
public static void main(String[] agrs){
Ramdon r=new Ramdon();
int[] x=new int[10];
//为数组赋值
for(int=0;i<x.length;i++){ x.length 表示数组的长度
x[i]=r.nextInt(3);
}
//输出数组的每一个数据
for(int i:x){
System.out.println("\t"+i);
}
}
}
数组的静态初始化：（在定义数组的同时就为数组元素分配空间并赋值）
如：int[] x={1,2,3,4}; -> 这里同样说明x.length=4
或-> int[] x=new int[]{3,4,5}
但是这样的方式就是错误的，int[4] x; //error
使用数组要注意的问题：
1、小标是从0开始的
2、所以不存在x[x.length]-> 否则会导致数组越界
多维数组：//java中多维数组不一定是规则的矩阵形式
int[行数][列数] x;
int[][] xx=new int[3][];//要构造这种不规则的是要顶下行数的，但是不能定在列数
xx[0]=new int[3]; xx[1]=new int[2]; xx[2]=new int[4];
->实例：
xx[0] 1 2 3
xx[1] 1 2
xx[2] 1 2 3 4
静态初始化：
可以这样：int[][] xx={{3,2,7},{1,5},{6}};
跟一位数组一样，这样也是错的，int[2][3]={{1,2,3},{1,2,3}};
数组的赋值->System.arraycopy(Object1,num1,Object2,num2,num)
int[] x={1,2,3,4,5};
int[] y=new int[5];
System.arraycopy(x, 0, y, 0,4);
for(int i:y){
System.out.println(i+"\t");
}
->Arrys.sort(Object) //从小到大排序
