达内javase_day2笔记

回顾:
1.java开发环境:
  1)java编译运行过程:
    1.1)编译期:.java源文件，经过编译，生成.class字节码文件
    1.2)运行期:JVM加载.class并运行.class
    跨平台、一次编程到处使用
  2)名词:
    2.1)JVM:java虚拟机
            加载.class并运行.class
    2.2)JRE:java运行环境
            JRE=JVM+java系统类库(小零件)
    2.3)JDK:java开发工具包
            JDK=JRE+编译、运行等命令工具
2.eclipse:
  1)开发步骤:
    1.1)新建Java项目
    1.2)新建Java包
    1.3)新建Java类，main(): System.out.println("Hello");
  2)注释:
    2.1)单行://
    2.2)多行:/* */
    2.3)文档:/** */-------------7月底

笔记:
1.变量:存数的，代词，指代的就是它所存的那个数
  1)声明:
      int a; //声明一个整型的变量，名为a
      int b,c,d; //声明三个整型的变量，名为b,c,d
  2)初始化:第一次赋值
      int a = 250; //声明整型变量a并赋值为250
      int a;   //声明整型变量a
      a = 250; //给变量a赋值为250
      a = 360; //修改变量a的值为360
  3)使用:
    3.1)对变量的使用就是对它所存的那个数的使用
          int a = 5;
          int b = a+10; //取出a的值5，加10后，再赋值给整型变量b
      System.out.println(b);   //输出变量b的值15
      System.out.println("b"); //输出b，双引号中的原样输出
      a = a+10; //取出a的值5，加10后，再赋值给变量a
                //在a本身基础之上增10
      System.out.println(a); //输出变量a的值15
    3.2)变量的使用必须与数据类型匹配
          int a = 3.14; //编译错误，数据类型不匹配
    3.3)变量在用之前必须声明并初始化
          System.out.println(m); //编译错误，m未声明
      int m;
      System.out.println(m); //编译错误，m未初始化
  4)命名:
    4.1)只能包含字母、数字、_和$符，并且不能以数字开头
    4.2)严格区分大小写
    4.3)不能使用关键字
    4.4)可以中文命名，但不建议
        建议"英文的见名知意"、"驼峰命名法"
2.基本数据类型:
  1)int:整型，4个字节，-21个多亿到21个多亿
    1.1)整数直接量默认int型，但不能超出范围，超范围则编译错误
    1.2)两个整型相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
    1.3)运算时超出范围，则发生溢出，溢出是需要避免的
  2)long:长整型，8个字节，很大很大很大
    2.1)长整型直接量需在数字后加L或l
    2.2)运算时若有可能溢出，建议在第1个数字后加L
    2.3)System.currentTimeMillis()用于获取
        自1970.1.1零时到此时此刻所经历的毫秒数
  3)double:浮点型，8个字节，
    3.1)浮点数直接量默认为double型，若想表示float，需在数字后加f或F
    3.2)double和float数据在运算时，有可能会发现舍入误差，精确场合不适用
  4)boolean:布尔型，1个字节
    4.1)布尔型只能取值为true或false
  5)char:字符型，2个字节
    5.1)采用Unicode字符集编码，一个字符对应一个码
        表现的形式是字符char，但实质上是码int(0到65535之间)
    ASCII码('a'--97  'A'--65  '0'--48)
    5.2)字符型直接量必须放在单引号中，只能有一个
    5.3)特殊字符需要通过来转义
3.基本数据类型间的转换:
    基本类型从小到大依次为:
      byte,short,int,long,float,double
            char,
  1)两种方式:
    1.1)自动类型转换:小类型到大类型
    1.2)强制类型转换:大类型到小类型
          (要转换成为的数据类型)变量
      强转有可能溢出或丢失精度
  2)两点规则:
    2.1)整数直接量可以直接赋值给byte,short,char，但不能超出范围
    2.2)byte,short,char型数据参与运算时，先一律转换为int再运算
4.Scanner接收用户的输入:
  1)在package下:
      import java.util.Scanner;
  2)在main方法中:
      Scanner scan = new Scanner(System.in);
  3)在第2步之下:
      System.out.println("请输入年龄:");
      int age = scan.nextInt();
      System.out.println("请输入价格:");
      double price = scan.nextDouble();

练习:---------------day03包中
1)创建类AgeRange，要求:
    接收用户输入的年龄age，并输出
2)创建类LeapYear，要求:
    接收用户输入的年份year，并输出
3)创建类Cashier，要求:
    完成课后作业第9题
4)将今天的小代码再重写至少一次

给变量赋值:
1)赋一个固定的值:
    int a = 5;
2)接收用户输入的值:----------Scanner
    int a = ?;
3)系统随机生成的值:----------周三下午讲
    int a = ?;

char ch = '\';

char ch = 'A';

发电报


字符char        码int
敌--------------1234
军--------------2234
来--------------3234
袭--------------4234
十进制:
1/2--------------0.5
1/4--------------0.25
1/3--------------0.3333333333333333333333...
2/3--------------0.6666666666666666666666...

二进制:
1/10

财务ERP----------------不能用double
                       BigDecimal

double a=3.0,b=2.9;
System.out.println(a-b); //0.10000000000000009
                         //0.1


double a=6.0,b=4.9;
System.out.println(a-b); //1.09999999999999996
                         //1.1

31536000000
         20亿(int)
long a = 1000000000*2*10L;
System.out.println(a); //200亿

         溢出
long b = 1000000000*3*10L;
System.out.println(b); //不是300亿

long c = 1000000000L*3*10;
System.out.println(c); //300亿

9223372036854775807
10000000000000000000--------BigInteger

直接量超范围则编译错误，运算超范围则溢出

int a = 10000000000;----------编译错误
int b = 1000000000*10;--------溢出

int balance = 2147483647;
balance = balance+1;--------------(-2147483648)

1G=1024M(兆)
1M=1024KB(千字节)
1KB=1024B(字节)
1B=8Bit(位)

1G=1024*1024*1024字节----------1073741824字节

37

够用就行

方便用户的选择
VarDemo
score,myScore,myJavaScore---------驼峰(变量)
Score,MyScore,MyJavaScore---------帕斯卡(类)
HelloWorld
int a;        //不直观
int 年龄;     //直观但不专业
int nianLing; //既不直观也不专业
int age;      //直观且专业

                         twoBagMnq
erJuanBianYaQi-----------二卷变压器
int a=5,b=10;
int c = a+b;
System.out.println(c);
早期的计算机-------算数(数字)
现在的计算机-------算数(数字、文字、图片、音频、视频等)
www.taobao.com-----------一个数据
淘宝首页-----------------一堆数据
手机壳-------------------一个数据
一堆手机壳---------------一堆数据
详细页面-----------------一堆数据
购物车-------------------一堆数据
结算---------------------一堆数据

package day02;
//变量的演示
public class VarDemo {
    public static void main(String[] args) {
        /*
         * 要求: 1.题目不用抄  2.注释不用写  3.有错必须改/注释
         * 1)声明一个整型的变量，名为a
         *   声明两个整型的变量，名为b和c
         * 2)声明整型变量d并直接赋值为250
         *   声明整型变量e，
         *     给变量e赋值为250
         * 3)声明整型变量f并赋值为10
         *     声明整型变量g并赋值为f+100，输出g的值
         *     在f本身基础之上增100，输出f的值
         *   声明整型变量h并赋值为36.789---------???
         *   输出变量i的值----------------------???
         *   声明整型变量i，输出i的值------------???
         * 4)声明几个正确的和几个错误的变量
         * 
         */        
        
        //1.变量的声明:
        int a; //声明一个整型的变量，名为a
        int b,c,d; //声明三个整型的变量，名为b,c,d
        
        //2.变量的初始化:第一次赋值
        int e = 250; //声明整型变量e并赋值为250
        int f;   //声明整型变量f
        f = 250; //给变量f赋值为250
        
        //3.变量的使用:
        int g = 5; //声明整型变量g并赋值为5
        int h = g+10; //取出g的值5，加10后，再赋值给整型变量h
        System.out.println(h);   //输出变量h的值15
        System.out.println("h"); //输出h，双引号中的原样输出
        g = g+10; //在g本身基础之上增10
        System.out.println(g); //15
        //int i = 3.14; //编译错误，数据类型不匹配
        //System.out.println(m); //编译错误，m未声明
        int m;
        //System.out.println(m); //编译错误，m未初始化
        
        //4.变量的命名:
        int a1,a_5$,_6b,$_;
        //int a*b; //编译错误，不能包含*号等特殊字符
        //int 1a; //编译错误，不能以数字开头
        int am = 5;
        //System.out.println(Am); //编译错误，严格区分大小写
        //int class; //编译错误，不能使用关键字
        int 年龄; //正确，但不建议
        int age; //建议"英文的见名知意"
        int score,myScore,myJavaScore; //驼峰命名法
    }
}

import java.util.Scanner; //1.
//Scanner的演示
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //2.
        System.out.println("请输入年龄:");
        int age = scan.nextInt(); //3.
        System.out.println("请输入价格:");
        double price = scan.nextDouble();
        
        System.out.println(age);
        System.out.println(price);
    }
}

package day02;
//数据类型的演示
public class DataTypeDemo {
    public static void main(String[] args) {
        /*
         * 基本类型间转换的练习:
         * 1)声明整型变量a并赋值为5
         *   声明长整型变量b并赋值为a
         *   声明整型变量c并赋值为b
         * 2)声明长整型变量d并赋值为100亿
         *     声明整型变量e并赋值为d，输出e
         *   声明浮点型变量f并赋值为36.987
         *     声明整型变量g并赋值为f，输出g
         * 3)声明short型变量s1并赋值为6
         *   声明short型变量s2并赋值为8
         *   声明short型变量s3并赋值为s1+s2
         * 4)输出0+0的值，输出'0'+'0'的值
         * 
         */
        
        //基本数据类型间的转换:
        int a = 5;
        long b = a; //自动类型转换
        int c = (int)b; //强制类型转换
        
        long d = 5; //自动类型转换
        double e = 5; //自动类型转换
        System.out.println(e); //5.0
        
        long f = 10000000000L;
        int g = (int)f; //强制类型转换
        System.out.println(g); //强转有可能会溢出
        double h = 25.987;
        int i = (int)h;
        System.out.println(i); //25，强转有可能会丢失精度
        
        byte b1 = 5;
        byte b2 = 6;
        byte b3 = (byte)(b1+b2);
        
        System.out.println(2+2);     //4
        System.out.println(2+'2');   //52
        System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50
        
        
        
        
        /*
         * boolean、char的练习:
         * 1)声明布尔型变量b1并赋值为true
         *   声明布尔型变量b2并赋值为false 
         *   声明布尔型变量b3并赋值为36.5-----???
         * 2)声明字符型变量c1并赋值为字符男
         *   声明字符型变量c2并赋值为字符m
         *   声明字符型变量c3并赋值为字符3
         *   声明字符型变量c4并赋值为空格符
         *   声明字符型变量c5并赋值为空字符-----???
         *   声明字符型变量c6并赋值为字符男性---???
         *   声明字符型变量c7并赋值为98，输出c7
         *   声明字符型变量c8并赋值为单引号(')，输出c8
         */
        
        /*
        //4.boolean:布尔型，1个字节
        boolean b1 = true;  //true为布尔型直接量
        boolean b2 = false; //false为布尔型直接量
        //boolean b3 = 250; //编译错误，布尔型只能取值为true或false
        
        //5.char:字符型，2个字节
        char c1 = '女'; //字符女
        char c2 = 'f'; //字符f
        char c3 = '6'; //字符6
        char c4 = ' '; //空格符
        //char c5 =  女; //编译错误，字符必须放在单引号中
        //char c6 = ''; //编译错误，不能是空字符
        //char c7 = '女性'; //编译错误，只能装一个字符    
        char c8 = 65; //0到65535
        System.out.println(c8); //A
        char c9 = '\';
        System.out.println(c9); //
        */
        
        
        /*
         * int、long、double类型的练习:
         * 1)声明整型变量a并赋值为36
         *   声明整型变量b并赋值为100亿---------???
         *   输出5/3的值，输出3/5的值，输出3.0/5的值
         *   声明整型变量c并赋值为2147483647(int的最大值)
         *     在c本身基础之上增1，输出c的值
         * 2)声明长整型变量d并赋值为100亿
         *   声明长整型变量e并赋值为10亿*2*10L，输出e
         *   声明长整型变量f并赋值为10亿*3*10L，输出f
         *   声明长整型变量g并赋值为10亿L*3*10，输出g
         *   声明长整型变量h并赋值为
         *     System.currentTimeMillis()，输出h
         * 3)声明浮点型变量i并赋值为3.14
         *   声明浮点型变量j和k，并分别赋为6.0和4.9
         *     输出j-k
         */
        
        /*
        //1.int:整型，4个字节，-21个多亿到21个多亿
        int a = 250; //250为整数直接量，默认为int型
        //int b = 10000000000; //编译错误，100亿默认为int型，但超出范围了
        System.out.println(5/2); //2
        System.out.println(2/5); //0
        System.out.println(5/2.0); //2.5
        int c = 2147483647; //int的最大值
        c = c+1;
        System.out.println(c); //溢出了-2147483648
        
        //2.long:长整型，8个字节，很大很大很大
        //long d = 10000000000; //编译错误，100亿默认为int型，但超出范围了
        long e = 10000000000L; //100亿L为long型直接量
        long f = 1000000000*2*10L;
        System.out.println(f); //200亿
        long g = 1000000000*3*10L;
        System.out.println(g); //溢出了(不是300亿)
        long h = 1000000000L*3*10;
        System.out.println(h); //300亿
        long i = System.currentTimeMillis();
        System.out.println(i);
        
        //3.double:浮点型，8个字节，很大很大很大
        double pi = 3.14159; //3.14159为浮点型直接量，默认为double型
        double j=6.0,k=3.9;
        System.out.println(j-k); //0.10000000000000009，有可能会发生舍入误差
        */
    }
}

JAVA Fundamental DAY02

1. 指出下面程序中的编译错误，并更正

int lenght=10；

System.out.println(length);

1. 指出下面程序中的编译错误，并更正

int age;

System.out.println(age);

1. 运行下面程序，指出变量的输出结果 

int count=30；

count=60；

System.out.println(count);

1. 指出下面程序中的编译错误，并更正

int &size=20；

System.out.println(&size);

1. 指出下面程序的编译或运行结果，并解释原因

int i=128;

i = 10000000008;

System.out.println(i);

1. 指出下面程序的运行输出结果

double width = 6.0;

double length = 4.9;

System.out.println(width - length);

1. 指出下面程序的输出结果

char ascii=98;

System.out.println(ascii);

1. 指出下面程序中的编译错误，并更正

byte b1=10;

byte b2=20;

byte b3=b1+b2;

1. 完成收银柜台收款程序V1.0

编写一个收银柜台收款程序。根据商品单价、购买数量以及收款金额计算并输出应收金额和找零，控制台交互情况如图-1所示。