Java学习笔记（一）

数据类型：

数据类型

位数

关键字

备注

整型

4

int

 

短整型

2

Short

 

长整型

8

long

 

字节型

1

byte

（常用于）图像，音频；视频

浮点型（单精度型）

4

float

符号；尾数；指数 （组成）/无法精确存储（一般为近似值）

双精度型

8

double

 

布尔型

 

boolean

True/false

字节型

2

char

用 unicode存储

 

常量：

字面值常量：

整型和平常书写习惯一样

常整型在整型字面值的后面加”L”;超出整型范围的数据，不加后缀字母亦按长整型存储

在数据后面加 “f”为单精度；否则（若该数是小数）默认为双精度

字符则是在要表达的字符符号前后加“’”(单引号)

 

符号常量

赋值关键表达式：

Final  数据类型 变量符号 = 常量；

赋值方式：

（1）声明时赋值（这里没有主函数感觉怪怪的）

     public class SignConst {

 final double PI = 3.14;

   

   public double GetArea ( double r )

   {

      return PI*r*r; 

    }

   

   public double GetCircle(double r)

   {

   return 2*PI*r;

   }

}

 

 

（2）使用构造器赋值

 

变量：

和符号常量相比，变量的不需要final 进行修饰，而且可以经常改变值；

public class VarExample {

 public static void main(String[] args )

 {

 int x;

 x=100;

 

 System.out.println(x);

 

 x=200;

 System.out.println(x);

 

 

 }

}

 

类型转换

自动类型转换：

在两个或者两个以上不同的数据进行计算时发生

原则 由低精度 转换为 高精度

（这里不知道要导入一个什么包才可以调用DiscernType）

public class KindTrans {

 public static void main(String[] args )

 {

 int a = 10;

 long b = 20L;

 System.out.println("表达式 a+b的类型为："+DiscernType.getType(a+b));

 

 double c = 3.14;

 

 System.out.println("表达式 b+c的类型为："+DiscernType.getType(b+c));

 

 }

}

 

强制类型转换

核心代码：

数据类型为a的数据 =（数据类型a）数据类型为b的数据；

注意：在有高精度的类型转为低精度类型的数据会丧失一定的精度

public class KindTrans {

 public static void main(String[] args )

 {

 

 long b = 11234567896L;

 int a = (int)b;

 System.out.println("a的类型为："+DiscernType.getType(a)); 

 System.out.println("b的类型为："+DiscernType.getType(b));

 System.out.println("a的值为："+a);

 System.out.println("b的值为："+b);

      

         B = 123456L;

         a = (int)b;

         System.out.println("a的值为："+a);

 System.out.println("b的值为："+b);

 

 }

}

 

变量的作用域：

Java 和C ++ 的不同之处为在同一个方法中，花括号内外Java是不可定义同一变量两次的，在下面代码的主方法中如果在定义了Y 的后面还定义一个X变量会报错。此外，在同一个类中，方法里面和方法外面可以定义同样的变量，并且方法中的变量会屏蔽方法外的变量。（唔，这里解释的不太清楚）

public class VarScope {

 public static void main(String[] args )

 {//x的有效范围

int x;

x = 5;//赋值方法一

{//y的有效范围

int y = 10;//赋值方法二

System.out.println("y的值为" + y);

}//y的有效范围

System.out.println("x的值为" + x);

 

 }//x的有效范围

 

}

局部变量的初始化：

方法内的变量称为局部变量，局部变量中除了数组和类的数据成员（这两个Java会对其自动初始化）外，如果不赋值就会无法使用，使用会报错。

 

赋值方法有在上面代码中有标出

 

装箱与拆箱

把基本数据类型转换为包装类型的过程称为装箱；

即将该基本数据类型转化为一个对象，有很多方法可以调用

装箱方法一（以整型为例，其他的数据类型装箱的关键字不一样）：

public class Wapping {

 public static void main(String[] args )

 {

int x;

x = 5;

Integer ox = new Integer(x);//装箱方法二：Integer ox = x;

System.out.println("ox的值为" + ox);

 

 }

}

但是方法二有一定的问题

public class Auto {

 public static void main(String[] args )

 {

int x;

x = 1000;//x = 10;

Integer ox = x;

Integer oy = x;

if(ox==oy)

    System.out.println("ox==oy");

else

System.out.println("ox!=oy");

 

 }

}

X=10时输出的是ox==oy

X=1000时 输出的是ox!=oy

  因为，Java对于-128到128之间的基本数据类型值进行自动装箱操作使之称为Integer对象之后，会对这些对象进行重用，在定义oy的时候由于已经有一个ox的/Integer对象，于是不会再重新开辟一个空间来生成这个对象，而是已经有的对象的引用赋值给oy.

  此外对比两个变量内容是否相等时 应当使用“equals”，而比较两个变量是否引用了同一个对象则使用“==”

 

拆箱:

public class SignConst {

 public static void main(String[] args )

 {

Integer ox = 10;

int y = ox;//拆箱

System.out.println(y);

System.out.println(ox);

System.out.println(y + ox);//与基本数据类型进行运算 拆箱

System.out.println(DisernType.getType(y+ox));

 

 }

}

 

表达式

算术表达式 里面有符号 + - * / % ++ -- 

赋值表达式 =

逻辑表达式 !;&&;||

关系表达式 > ;< ;>=;<=;==;!= 该表达式只有 真和假 两个值

这些符号有不同的优先级，加括号感觉比较方便

 

位运算（将数据化为二进制后进行运算）

按位与运算 &

按位或运算 |

按位异或运算 ^

移位运算 <<左移;>>右移；>>>无符号右移运算

左移 低位补零 有改变数字符号的风险

右移 高位 正数补0 负数补1

无符号右移 高位都补0 负数有改变符号和数据大小的风险

取反运算～

特殊情况 数值为0时取反为-1，数值为-1时取反为0 其他时候该二进制位上原来是0则变为1，1变为0

（我有点好奇对于整数负数和离存储的最大值较远的取反是怎么回事）

 

程序流程控制

顺序结构

分支结构

1，If

2，If 嵌套

3，Switch 语句

switch(表达式)

case（常量表达式）：执行语句；break；

default：执行语句；break；

表达式必须是整型或者是字符型；

常量表达式必须是整型或者字符型常量；

default可以没有；在有多个case的情况下，如果该case后面没有break离开switch语句，那么在执行完该case的执行语句后会继续执行下一个case里面的执行语句；

case里面的执行语句可以为空；

如果有多个值需要执行的执行语句一样可以用下面的形式

switch(表达式)

    case（常量表达式）：break；

    case（常量表达式）：break；

case（常量表达式）：执行语句；break；

default：执行语句；break；

 

循环结构

For(表达式1；表达式2；表达式3)

{循环体}

表达式1 初始化循环变量；

表达式2 决定循环体执行的次数；该表达式逻辑为真值时，执行循环体

表达式3 改变循环变量的值；

表达式1可以在提前，从而在for后面的括号内被省略

表达式3 可以放入循环体，从而在for后面的括号内被省略

 

While（表达式）

{循环体}

这里的表达式和for中的表达式2类似

 

Do

{循环体}while(表达式);

后面分号不能省，表达式和for中的表达式2类似

 

Break；continue；

Break 是用来跳出最里层的循环；

Continue 是用来跳过循环中的一次循环，如果遇到了continue则continue后面的（但是实在循环内部的）语句均不执行，直接跳过这些语句，开始新一次的循环。

 

习题

1.编程输出数字 13 除以 5 的商和余数

2.输出1000以内的水仙花数

3.输出100以内的同时能被3和4整除的数字且考虑效率问题

4.可以用整型数的16个二进制单位表示16支足球队伍的出线情况，1：出线；0：不出线；由低到高分别为1，2，3.……16队，如果现在int 的值为50083，问：哪些队伍获得了出线权？

答案

1.

public class SignConst {

 public static void main(String[] args )

 {

System.out.println("13除以5的商为："+(13/5));

System.out.println("13除以5的余数为："+(13%5));

 

 }

}

2.

public class SignConst {

 public static void main(String[] args )

 {

int a=0,b=0,c=0;

for(int i = 100; i < 1000; i++)

{

a=(i/100);

b=(i-100*a)/10;

c=i-a*100-b*10;

if (i == a*a*a+b*b*b+c*c*c)

System.out.println(i);

}

 

 }

}

3.（不知道要怎么考虑效率问题）

public class SignConst {

 public static void main(String[] args )

 {

for(int i = 12; i < 100; i++)

{

if ( i % 12 == 0)

System.out.println(i);

}

 

 }

}

4.

public class SignConst {

 public static void main(String[] args )

 {

int a=50083;

for(int i = 1; i < 17; i++)

{

if ( a % 2 == 1)

System.out.println("获得出线权的是第"+i+"队");

a=a/2;

}

 

 }

}

 

public class SignConst {

 public static void main(String[] args )

 {

int a=50083;

for(int i = 1; i < 17; i++)

{

if ( (a&1) == 1)

System.out.println("获得出线权的是第"+i+"队");

a=a>>1;

}

 

 }

}