动手动脑自信成就人生

动手动脑1

✿仔细阅读示例: EnumTest.java，运行它，分析运行结果？

package demo;

public class Test {

public static void main(String[] args) {

Size s=Size.SMALL;

Size t=Size.LARGE;                                                    //s和t引用不同对象

System.out.println(s==t);                                           //false

System.out.println(s.getClass().isPrimitive());                //false 不是原始数据类型

Size u=Size.valueOf("SMALL");                                     //从字符串中转换

System.out.println(s==u);                                           //true

for(Size value:Size.values()){                                       //列出它的所有值

System.out.println(value);

}

}

}

enum Size{SMALL,MEDIUM,LARGE};

运行结果为：SMALL  MEDIUM  LARGE

✿你能得到什么结论？你掌握了枚举类型的基本用法了吗？

枚举类型的常量以字符串的形式顺序储存，Size value：Size.value() 可遍历Size中的所有值，int ordinal() 可返回其在enum(enumerate)中的位置，构造函数和覆写toString()的方法可给枚举类型赋值……

动手动脑2

✿你看到了什么样的输出，意外吗？为什么double类型的数值进行运算得不到“数学上精确”的结果？

运行结果：

0.05+0.01=0.060000000000000005

1.0-0.42=0.5800000000000001

4.015*100=401.49999999999994

123.3/100=1.2329999999999999

无论是单精度还是双精度在计算机中的储存都分为三个部分：符号位(0代表正，1代表负)、指数位(用于储存科学计数法中的指数数据，并且采用移位存储)、尾数部分。比如8.25和120.5的科学计数法表示为：十进制8.25*10^0、1.205*10^2，二进制1.0001*2^3、1.1101101*2^6，这些数以二进制形式存储在计算机里时，会出现00110011001100110011……的无限循环系列，在进行数据类型转换时会出现误差，而能够用二进制表示十进制数据(比如2.25)，这个误差就不存在。(本节参考博客园jillzhang@126.com)。

动手动脑3

✿以下代码的输出结果是什么？

int X=100;

int Y=200;

System.out.println("X+Y="+X+Y);

System.out.println(X+Y+"=X+Y");

输出结果：X+Y=100200  300=X+Y

✿为什么会有这样的输出结果

输出语句1里“+”为连接运算，与("X+Y="+(X+Y));不同，输出字符串“X+Y=”与X与Y，输出语句2里第一个“+”为加法运算符，第二个“+”为连接运算符。

动手动脑4

✿阅读相应教材，或者使用互联网搜索引擎，弄清楚反码、补码跟原码这几个概念，然后编写示例程序，对正数、负数进行各种位操作，观察输出结果，与手工计算的结果进行比对，看看Java中的数是采用上述哪种码表示的。

数在计算机中是以二进制形式表示的，分为有符号数和无符号数，原码、反码、补码都是有符号定点数的表示方法。一个有符号定点数的最高位为符号位,0是正,1是负(以8位整数为例)，例如0000001 就是+1，1000001 就是-1，原码就是这个数本身的二进制形式，正数的反码和补码都是和原码相同，负数的反码是将其原码除符号位之外的各位求反 [-3]反=[10000011]反=11111100 。负数的补码是将其原码除符号位之外的各位求反之后在末位再加1，[-3]补=[10000011]补=11111101 。一个数和它的补码是可逆的。特别注意，如果+1之后有进位的,要一直往前进位,包括符号位!(这和反码是不同的!)[10000000]补=[10000000]反+1=11111111+1=(1)00000000=00000000(最高位溢出了,符号位变成了0)

为什么要设立补码呢?

通过补码运算，可以把减法运算变成加法运算；而乘法可以用加法来做，除法可以转变成减法。这样一来，加、减、乘、除四种运算“九九归一”了。这对简化CPU的设计非常有意义，CPU里面只要有一个加法器就可以做算术运算了。还有一个原因是为了统一正0和负0，正零：00000000 负零：10000000 这两个数其实都是0,但他们的原码却有不同的表示，但是他们的补码是一样的，都是00000000。

源代码

package demo;

public class Bit {

public static void main(String[] args) {

// TODO 自动生成的方法存根

System.out.println(3<<2);//3左移2位 把整数m(3)表示的二进制数左移n(2)位,高位移出n位都舍弃，低位补0.(此时将会出现正数变成负数的形式)

System.out.println(-3<<2);//-3左移2位

System.out.println(6>>2);//6右移2位 把整数m表示的二进制数右移n位,m为正数，高位全部补0；m为负数，高位全部补1.

System.out.println(-6>>2);//-6右移2位

System.out.println(-6>>>2);//-6无符号右移2位 整数m表示的二进制右移n位，不论正负数，高位都补零。

}

}

结果截图为：

动手动脑5

✿Java变量遵循“同名变量的屏蔽原则”，请课后阅读相关资料弄清楚相关知识，然后自己编写一些测试代码，就象本示例一样，有意识地在不同地方定义一些同名变量，看看输出的到底是哪

1、局部变量与成员变量

区分两个同名变量可以通过给成员变量名添加前缀的方式。如果类名为A.则

System.out.println("Time输出值："+time);//输出局部变量的值

System.out.println("成员变量Time输出值："+A.time);//输出成员变量的值

2、子类与父类

在JAVA中，子类可以继承父类，子类声明的方法与父类有重名时分为两种情况，方法和变量在继承时的覆盖和隐藏问题。

隐藏 ：子类隐藏了父类的变量和方法，那么，子类不能访问父类被隐藏的变量或者方法，但是，将B转换成A中，可以访问A被隐藏的变量或者方法

覆盖 ：子类覆盖了父类的变量或者方法，那么，子类不能访问父类被覆盖的变量或者方法，将子类转换成父类后同样不能访问父类被覆盖的变量或者方法

java中类是分层次的，当子类和父类的定义同名时，父类变量被隐藏，父类的实例方法被重写，静态方法属于类级别的方法，在子类和父类中互不相碍。

Java代码示例：

class Parent{

int i=10;// 父类变量

public void setI(int i){

this.i=i;

}

}

class Son extends Parent{

int i=10;// 子类与父类同名的变量

public static void main(String args[]){

Son son=new Son();

System.out.println("son.i="+son.i);

son.setI(100);

System.out.println("After setI(100) : son.i="+son.i);

Parent parent=son;

System.out.println("See son as Parent : son.i="+parent.i);

}

}

运行的结果：

son.i=10

After setI(100) : son.i=10

See son as Parent : son.i=100

在这段代码中，子类定义了一个父类中同名的成员变量int i，在父类中有一个对 i 赋值的方法setI()，而在子类中没有定义这个方法。当子类调用继承而来的setI()方法对成员变量i进行改变，直接打印son.i(对照代码)时，成员变量i然而却没有改变。但当把son当作Parent类型来使用，再打印它的成员变量i时，输出的结果就对了，是setI()改变之后的值。

动手动脑6

✿看着这个图，再查查Java中每个数据类型所占的位数，和表示数值的范围，你能得出什么结论？

1.Int       32位    4字节      -2147483648~~~2147483647

2.Short     16位    2字节      -32768~~~32678

3.long      64位    8字节      -9223372036854775808~~~9223372036854775807

4.float     32位    4字节      -340292347E+38~~~+340292347E+38

5.double    64位    8字节      -1.79769313486231576E+308~~~1.79769313486231576E+308

6.char      16位    2字节      ‘\u0000′‘~~~‘\uFFFF’

7.boolean    1位   0.125字节   true/false

8.byte       8位    1字节       -128~~~127

(在转换时遵循以下原则：从低精度向高精度转换、基本类型向类类型转换、类类型向字符串转换、基本类型向字符串的转换)

byte，short，char之间不会互相转换，并且三者在计算时首先转换为int类型

1、自动类型转换

自动类型转换，也称隐式类型转换，是指不需要书写代码，由系统自动完成的类型转换。由于实际开发中这样的类型转换很多，所以Java 语言在设计时，没有为该操作设计语法，而是由 JVM 自动完成。

转换规则：从存储范围小的类型到存储范围大的类型。

具体规则为：byte→char→int→long→float→double。也就是说 byte 类型的变量可以自动转换为char类型，示例代码：

byte b=10;

char sh=b;

在类型转换时可以跳跃。示例代码：

byte b1=100;

int n=b1;

注意问题:在整数之间进行类型转换时，数值不发生改变，而将整数类型，特别是比较大的整数类型转换成小数类型时，由于存储方式不同，有可能存在数据精度的损失。

2、强制类型转换

强制类型转换，也称显式类型转换，是指必须书写代码才能完成的类型转换。该类类型转换很可能存在精度的损失，所以必须书写相应的代码，并且能够忍受该种损失时才进行该类型的转换。

转换规则:从存储范围大的类型到存储范围小的类型。

具体规则为：double→float→long→int→short(char)→byte

语法格式为：(转换到的类型)需要转换的值

示例代码：

double d=3.10;

int n=(int)d;

这里将 double 类型的变量 d 强制转换成 int 类型，然后赋值给变量 n。需要说明的是小数强制转换为整数，采用的是“去 1 法”，也就是无条件的舍弃小数点的所有数字，则以上转换出的结果是 3。整数强制转换为整数时取数字的低位，例如 int 类型的变量转换为 byte 类型时，则只去 int 类型的低 8 位(也就是最后一个字节)的值。

示例代码：

int n=123;

byte b=(byte)n;

int m=1234;

byte b1=(byte)m;

则 b 的值还是 123，而 b1 的值为-46。b1 的计算方法如下：m 的值转换为二进制是10011010010，取该数字低8位的值作为b1的值，则b1的二进制值是11010010，按照机器数的规定，最高位是符号位，1 代表负数，在计算机中负数存储的是补码，则该负数的原码是 10101110，该值就是十进制的-46。

动手动脑7

✿编写一个程序，用户输入两个数，求出其加减乘除，并用消息框显示计算结果

package demo;

import javax.swing.JOptionPane;

public class Test{

public static void main(String[] args) {

int n1=Integer.parseInt(JOptionPane.showInputDialog("Input number 1: "));

int n2=Integer.parseInt(JOptionPane.showInputDialog("Input number 2: "))    //获取从JOptionPane.showInputDialog对话框中输入的值，然后转换为int类型

JOptionPane.showMessageDialog(null,"The sum is:"+(n1+n2)

+"\n"+"The difference is:"+(n1-n2)

+"\n"+"The product is:"+(n1*n2)

+"\n"+"The division is:"+(n1/n2));

}

}

结果截图为：

除数为0时报错