00动手动脑

public class EnumTest {
    
    public static void main(String[] args) {
        Size s=Size.SMALL;
        Size t=Size.LARGE;
        //s和t引用同一个对象？
        System.out.println(s==t);  //
        //是原始数据类型吗？
        System.out.println(s.getClass().isPrimitive());
        //从字符串中转换
        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};

 

运行程序结果：

 

定义一个枚举类Size

s为Size中的SMALL

t为Size中的LARGE

1.判断s与t是否相等，输出false

2.判断s是原始数据类型，原始数据类型（boolean、char、byte、short、int、long、float、double），不是输出false

3.valueOf()方法返回指定字符串值的枚举常量。u为Size中的SMALL，判断s与u是否相等，输出true

4.迭代输出Size中各元素

 

枚举类型的基本用法：

java枚举类用enum关键字定义，内部各常量用,分割

例：enmu Color{RED,GREEN,BLUE;}

枚举类的声明可在外部也可在内部类，EnumTest的例子在外部

这个是在内部

public class Test

{

　　enmu Color{RED,GREEN,BLUE;}

　　public static void main(String[] args)

　　{

　　　　Color c1=Color.RED;

　　　　System.out.println(c1);

　　}

}

输出结果：RED

利用for语句迭代枚举元素

EnumTest例子中就是迭代输出枚举各元素

 

 

 例2：

enmu Color{RED,GREEN,BLUE;}
public class MyClass {
  public static void main(String[] args) {
    for (Color myVar : Color.values()) {
      System.out.println(myVar);
    }
  }
}
输出结果：
RED
GREEN
BLUE

在switch语句中使用枚举类：

enmu Color{RED,GREEN,BLUE;}
public class MyClass {
  public static void main(String[] args) {
    Color myVar = Color.BLUE;
    switch(myVar) {
      case RED:
        System.out.println("红色");
        break;
      case GREEN:
         System.out.println("绿色");
        break;
      case BLUE:
        System.out.println("蓝色");
        break;
    }
  }
}

 

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

反码：正数的反码还是等于原码；负数的反码就是他的原码除符号位外，按位取反。

补码：正数的补码等于他的原码，负数的补码等于反码+1。

原码：是最简单的机器数表示法。用最高位表示符号位，‘1’表示负号，‘0’表示正号。其他位存放该数的二进制的绝对值。

原码、补码、反码的深入理解与原理

首先先猜想是由原码表示，程序验证

1         int a=1;

2         int b=-1;

3         int sum=a+b;

4         System.out.println(sum);

 

可知程序的结果为0，而在二进制中00000001+10000001=10000010，换算成十进制为-2。显然出错，故java中数值并非是由原码储存

同理，在使用反码表示时，也会出现同样的问题： (00000001) 反+ (11111110)反 = (11111111)反 = ( -0 )

而在补码中这没有这个问题：(00000001)补 + (11111111)补 = (00000000)补 = ( 0 )

结论:在java中，数值是由补码表示的

   (摘自:   https://www.cnblogs.com/heiyang/p/9748054.html  )

 

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

 

package day02;

public class Test {

    private static int value=1;    

    public static void main(String[] args) {

        int value=2;

        System.out.println(value);

    }

}

结果为  2

 

 

 

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

 

java中有8种基本数据类型：byte、int、short、long、boolean、char、float、double

 

对应的类为：Byte、Int、Short、Long、Boolean、Charecter、Float、Double

 

逻辑型：boolean

 

文本型：char

 

整数型：byte、short、int、long

 

浮点型：float、double

 

byte：    1字节 -128~127

 

short：   2字节 -2^15~2^15-1

 

int ：      4字节 -2^31~2^31-1

 

long：    8字节 -2^63~2^63-1

 

boolean:1字节 true false（java中不能以0或非0代替）

 

float：    4字节 -3.403E38~3.403E38

 

double：8字节 -1.798E308~- 4.9E324

 

char：    2字节  ’\u0000‘~‘ ’\uffff ‘(16进制的，换算过来即0~65535)

 

（1字节等于8位）

 

结论：由基本到复杂。

 

除了使用C的强制类型转换方式，还可以通过原始类型的包装类完成类型转换。

 

 

适用场景：同一个数据需要转换为多种类型，并且这一数据需要比较长期的使用。多数情况下，推荐直接使用强制类型转换的方式。

 

 TestDouble.java

public class TestDouble {

    public static void main(String args[]) {

        System.out.println("0.05 + 0.01 = " + (0.05 + 0.01));

        System.out.println("1.0 - 0.42 = " + (1.0 - 0.42));

        System.out.println("4.015 * 100 = " + (4.015 * 100));

        System.out.println("123.3 / 100 = " + (123.3 / 100));

    }

}

 

 

 

为什么double类型的数值进行运算得不到“数学上精确”的结果？

答：涉及到二进制与十进制的转换问题。

N进制可以理解为：数值×基数的幂，例如我们熟悉的十进制数123.4=1×10²+2×10+3×(10的0次幂)+4×(10的-1次幂)；其它进制的也是同理，

 

例如二进制数11.01=1×2+1×(2的0次幂)+0+1×(2的-2次幂)=十进制的3.25。

 

double类型的数值占用64bit，即64个二进制数，除去最高位表示正负符号的位，在最低位上一定会与实际数据存在误差（除非实际数据恰好是2的n次方）。

 

举个例子来说，比如要用4bit来表示小数3.26，从高到低位依次对应2的1,0,-1,-2次幂，根据最上面的分析，应当在二进制数11.01(对应十进制的3.25)和11.10(对应十进制的3.5)之间选择。

 

简单来说就是我们给出的数值，在大多数情况下需要比64bit更多的位数才能准确表示出来（甚至是需要无穷多位），而double类型的数值只有64bit，后面舍去的位数一定会带来误差，无法得到“数学上精确”的结果。

 

 

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

int X=100;

int Y=200;

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

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

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

 

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

 

字符串转为数字的基本方法：

 

int number =Integer.parseInt(numberString);

类lnteger属于包 java.lang,它封装了一个int类型的整数，因此，它是原始数据类型int的“包装类”。

　

 

字符串转为浮点数：　

 

number1=Double.parseDouble(firstNumber);

number2=Double.parseDouble(secondNumber);