Day02

day02

1. 基本概念
   1. 注释

1. 注释 : 对逻辑代码起到解释说明的作用
2. 注释的分类:

1. 单行注释 : 每次注释一行内容   // 之后的部分是单行注释 , 可以嵌套使用
2. 多行注释 : 每次可以注释多行内容, 可以设计回车换行, 但是多行注释不能嵌套使用

   /*

        多行注释的内容

        可以任意写

*/

 

1. 注释其实非常重要,在代码中,每一个程序员都必须写注释, 实际项目中, 注释内容大概会占有整个代码行数30% 左右
2. 注释不会影响代码的运行结果 :

1. 编译时, 不检查注释写作内容
2. 运行时, 不运行注释内容

 

 

代码

package com.ujiuye.base;   // class 表示类, 具有独立功能Java类型文件 , 这个类的名字为 "Demo01_注释" public class Demo01_注释 {     /*      *   1. main方法是程序的唯一执行入口,所有的代码都是从main开始执行      *   2. JVM虚拟机在进行代码运行时, 主动运行main      *   3. 目前, 在main中,设计功能 : 将数据"今天星期二" 进行输出打印      *   // 嵌套的单行注释      *      * */ public static void main(String[] args) {        System.out.println("今天星期二!!!");// 输出打印数据 } }

 

1. 1. 关键字
2. 关键字 : Java代码中具有特殊含义, 特殊的使用方式的英文单词, 称为关键字

 

 

1. 注意:

1. 所有的关键字都是小写字母组成(没有大写,数字, 符号,空格出现)
2. 关键字不能单独作为名字出现
3. 在集成开发工具eclipse中, 每一个关键字都具有特殊颜色

 

1. 1. 标识符
2. 标识符 : 在Java代码中,如果给类, 接口, 变量, 方法,常量进行命名,需要符合标识符的命名规则
3. 标识符的组成:

1. a-z A-Z 字母
2. 所有数字
3. 特殊符号 : _ $
4. 其他国家语言文字 : 例如 : 中文, 实际开发中, 没有中文命名

 

1. 标识符规范:

1. 关键字不能单独作为名字出现
2. 数字不作为名字的开头

 

代码

package com.ujiuye.base; public class Demo02_标识符规范 { public static void main(String[] args) {          int _12 = 10;          // int class = 20;  class是关键字, 关键字不能单独作为名字出现                    int class1 = 10;                   // int 16abc = 10; 16abc 错误名字, 命名数字不能作为名字的开头                    int my_name = 10;                   // int my name = 20; my name 错误名字, 名字中不能出现空格                   // int  %abc = 10;  %abc错误名字, % 不能作为特殊字符存在于名字中, 特殊符号只有 _ 和 $ } }

 

 

1. 1. Java行业内部命名规则
2. 包的命名: package, 全球唯一, 公司域名的倒写

   举例 : com.ujiuye.base(包名)

1. 类和接口命名:

   大驼峰原则, 每个英文单词的首字母都大写

   举例 : HelloWorld  

1. 方法的命名 :

   小驼峰原则, 第一个英文单词全小写, 从第二个英文单词开始首字母大写

   举例 :  getSum    salePru

1. 变量的命名 : 与方法命名一致

   举例 : count  schoolName  

1. 常量的命名 : (面向对象环节涉及到符号常量的命名)

   全大写, 多个英文单词之间使用_进行分隔

   举例 : PI   COPY_NAME

 

 

1. 常量

1. 常量 : 在Java代码的运过程中, 其值不会发生变量的量(数据), 称为常量
2. 常量按照表示形式分类:

1. 直接在代码中写出的数据,字面值常量  3   3.14
2. 符号常量 : 讲到面向对象final关键字,涉及到符号常量, 目前只铺垫

1. 常量按照数据类型分类:

1. 基本数据类型常量: 用于表示最简单,最直接的数据,分为4类

   a : 整数类型  -9  0  45

   b : 浮点类型(小数类型)  -0.98  0.0  67.45

   c : 字符类型 : 使用一对引文的单引号包裹起来的一个字符

      ‘a’ ‘A’ ‘1’ ‘?’ ‘家’  ‘’--->不是字符  ‘-1’--->不是字符,2个

   d : 布尔类型 : 用于判断真假值结果, 布尔类型的值只有两种  true(真)  false(假)

1. 引用数据类型常量:

   引用数据类型 : 表示比较复杂的数据, 例如 : 客户信息, 每个客户都具有的信息 : 姓名, 电话号码, 家庭住址...

      a : 字符串常量, 字符串就是一种引用数据类型

          使用一对英文的双引号包裹起来的一系列字符序列,称为字符串类型

      b : 空常量 : 引用数据类型的默认值可以设置为null, null表示空常量

 

代码

package com.ujiuye.variable; public class Demo03_常量 { public static void main(String[] args) {          // 1. 整数常量  //  System.out.println : 表示将小括号中的数据进行输出打印, println表示带有回车换行的打印, 打印数据完毕之后, 数据后面添加一次回车换行  System.out.println(-9);  System.out.println(0);  System.out.println(9);    // 2. 浮点类型  System.out.println(0.0);  System.out.println(3.14);    // 3. 字符类型  System.out.println('a');  System.out.println('A');  System.out.println('1');  System.out.println('?');  System.out.println('家');  // System.out.println('');  // System.out.println('-1');    // 4. 布尔类型  System.out.println(true);  System.out.println(false);    // 5. 字符串类型  System.out.println("123abc  ...?在家吗?");  System.out.println("2020年7月21日");  System.out.println("2020-7-21");    // 6. null 表示空常量, 引用数据类型的默认类可以设置为null  //  周五, 讲数组, 再使用null  String s = null;  System.out.println(s); } }

 

 

1. 变量
   1. 变量的定义

1. 变量 : 在Java代码运行的过程中, 其值有可能发生变量的量(数据), 称为变量
2. 变量的使用场景 : 表示一个人的年龄, 体重 , 电话号码, 家庭住址...
3. 变量的定义:

   数据类型  变量名 = 值;

1. 数据类型 : 表示当前的数据属于什么类型
2. 变量名 : 标识符规范, 小驼峰原则, 从第二个英文单词开始,首字母大写
3. = : 赋值运算符, 将等号右边的数值, 赋值给等号左边的变量名, 在接下来的代码中,就是使用这个变量名表示对应的数值
4. 值 : 数值只需要符合对应的数据类型即可

 

 举例 : int i = 10;// int表示整数类型

 

1. 定义出一个变量的同时,这个变量需要占有一块内存区域

  内存 : 表示空间位置, 举例 : 内存4GB

内存存在意义: 如果有应用程序或者是代码需要执行, 进入到内存中占有一部分空间执行; 当程序或者应用执行完毕,出内存,释放掉占有的内存空间

  

 

代码

package com.ujiuye.variable; public class Demo04_变量的定义和赋值 { public static void main(String[] args) {            // 数据类型  变量名 = 值;    int i = 10;// 定义出一个int(整数类型)变量, 变量名为i ,表示的数据值为10    System.out.println(i);// 10        // 对于变量i的使用, 给i变量赋值, 新值为20    i = 20;    System.out.println(i);// 20 } }

 

1. 1. 数据类型
2. 内存区域的存储单位:

1. 计算机中,文件或者数据最小丈量粒度是字节
2. 内存区域之间的转换单位:

   1024字节 = 1KB(千字节)

   1024KB = 1MB

   1024MB = 1GB

   1024GB = 1TB

   ...

 

1. Java语言是强类型语言, 定义一个变量时, 必须给出这个变量对应的数据类型, 不同的数据类型在内存中占有的空间大小不同

 

1. 四类八种基本数据类型:

1. 整数类型

   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

1. 浮点类型(小数类型)

   float   单精度  4字节

   double 双精度  8字节(最常用浮点类型)

1. 字符类型

   char   2字节  0-65535

1. 布尔类型

        boolean 未知  true(真)  false(假)

注意 : 四类八种基本数据类型,全部都是关键字

 

代码

package com.ujiuye.variable; public class Demo05_四类八种基本数据类型 {     // 变量名不要重复 public static void main(String[] args) {         // 1. 整数类型 byte b = 15; System.out.println(b);   short s = 200; System.out.println(s);   int i = 1000; System.out.println(i);   long l = 1200; System.out.println(l);   // 2. 浮点类型 // float类型数据需要添加F作为单精度的标识 float f = 3.14F; System.out.println(f);   double d = 5.6789; System.out.println(d);   // 3. 字符类型 char ch = 'A'; System.out.println(ch);   // 4. 布尔类型 boolean boo = true; boolean boo1 = false; System.out.println(boo); System.out.println(boo1); } }

 

 

1. 1. 常量的默认类型
2. Java中, 任意写出的整数,必须在int类型数据范围之内. Java中,没有确定数据类型的整数默认是int类型, 当定义一个long类型数据时, 如果数据范围超过了int类型, 需要在数据之后添加L作为长整型的标识

 

1. Java中, 浮点类型默认就是double类型, 因此定义float类型时, 数据后需要添加F作为单精度的标识

 

代码

package com.ujiuye.variable; public class Demo06_常量的默认类型 { public static void main(String[] args) {         byte b = 12;                  long lon = 1500;                  // The literal 12345678907654 of type int is out of         // 当定义一个long类型数据时, 如果数据范围超过了int类型,         // 需要在数据之后添加L作为长整型的标识         long lon2 = 12345678907654L;                  System.out.println(12);// 12就是int类型                  //Type mismatch: cannot convert from double to float         float f = 3.14F;                  System.out.println(4.5); // 4.5 就是double类型 } }

 

 

1. 1. 变量定义的注意事项
2. 变量定义后,具有使用范围

   自变量定义后, 包含这个变量本身, 离这个变量最近的一对大括号就是这个变量的使用范围

1. 相同作用域的变量名不能重复
2. 变量的声明和变量的赋值可以分开

   int y; // 变量的声明

   y = 25; // 变量赋值

1. 方法中定义的变量,如果不赋值,不能使用
2. 相同数据类型变量可以连续定义(不建议,后期维护难度大,了解)

 

代码

package com.ujiuye.variable; public class Demo07_变量定义的注意事项 { public static void main(String[] args) {          //1. 变量的使用范围   int i = 10;      {   int y = 20;   System.out.println(i + y);// 30   }   // y cannot be resolved to a variable   // y无法被解析成一个变量, y超出了使用范围   // System.out.println(y);      // 2. 变量名不重复   int w = 15;   // double w = 3.14;   // int w = 25;   // System.out.println(w); w值使用矛盾问题, 语法错误      // 3. 变量的声明和变量的赋值可以分开   int u;   // The local variable u may not have been initialized(初始化,表示赋值)   // 4. 方法中定义的变量,如果不赋值,不能使用   // System.out.println(u);   u = 25;   System.out.println(u);// 25      // 5.相同数据类型变量可以连续定义(不建议,后期维护难度大,了解)   double d1 = 3.14 , d2 = 5.27; } }

 

 

1. 1. 数据类型转换之自动类型转换
2. 自动类型转换(隐式转换) : 小的数据类型与大的数据类型进行运算, 小类型数据需要自动提升类型为大的数据类型, 提升完毕进行运算, 结果以大的数据类型为准
3. 四类八种基本数据类型之间大小排列顺序:

   byte < short = char < int < long < float < double  boolean类型不参与比较和运算

1. 注意事项:

   byte, short,char,int类型自身或者彼此之间进行运算, 统统自动提升类型为int,如果在运算过程中,有比int类型更大的数据类型, 以最大数据类型为提升标准

 

  代码

package com.ujiuye.variable; public class Demo08_自动类型转换 { public static void main(String[] args) {           byte b = 15;           int i = 20;           // 运算过程 :           // 1) b自动提升类型为int  15           // 2) 15 + 20 = 35 --->int           int result = b + i;           System.out.println(result);// 35                      short s = 300;           // 自动小数据类型转换成大数据类型           int w = s;                                 byte b1 = 20;           short s1 = 30;           // 运算过程:           // 1) b1自动提升类型为int           // 2) s1自动提升类型为int           // 3) 两个int类型数据运算,结果int类型           int ss = b1 + s1;           System.out.println(ss); } }

 

 

1. 1. 数据类型转换之强制类型转换
2. 大的数据类型转换成小的数据类型, 需要强制类型转换
3. 公式:

  小数据类型 变量名 =  (小数据类型)大类型数据;

1. 强制类型转换过程中, 有可能导致数据的丢失或溢出, 强转需谨慎

 

代码

package com.ujiuye.variable; public class Demo09_强制类型转换 { public static void main(String[] args) {         int i = 39;         // 小数据类型 变量名 =  (小数据类型)大类型数据;         byte b = (byte)i;         System.out.println(b);// 39                  // 计算机世界中,所有的数据都是以二进制进行存储, 逢二进1         // 0 1 10---->2  11--->3         int y = 1000;         // y二进制存储100100110         // 连续的8个二进制位就是1个字节大小         byte b1 = (byte)y;         // 因为强制类型转换, 导致数据的丢失或溢出         System.out.println(b1);// -24                  double d = 3.55;         int result = (int)d;         System.out.println(result);// 3 } }

 

 

1. 1. 字符类型
2. 字符类型 : char , 使用一对英文的单引号包裹起来的一个字符,基本数据类型
3. 计算机世界中,对于数据都是以二进制的形式存储, 0和1, 字符也是使用0和1进行表示, 于是人类语言(字符)需要与数字有对应关系, 最基本的对应关系就是ASCII编码表
4. 在ASCII编码表中, 常用的字符, 需要记忆

   0-9 : 48----57

1. Z : 65---90

a-z : 97---122

 

1. 中国有自己的编码表:

1. GBK : 中国标准编码表, 底层兼容ASCII编码, 包含所有的中文文字, 一个中文在GBK编码下,占有2字节大小
2. UTF-8 : 万国码表, 底层兼容ASCII编码, 汇集了世界上多国语言文字, 一个中文在UTF-8编码下,占有3个字

 

代码

package com.ujiuye.variable; public class Demo10_字符类型与编码表 { public static void main(String[] args) {         char ch = 'A'; // 编码表中对应65         // 运算过程:         // 1) ch  通过编码表将字符'A'对应的整数65获取到,自动提升类型为 int         // 2) 65 + 5 = 70--->int         int re = ch + 5;         System.out.println(re);// 70                  char ch1 = (char)re;         System.out.println(ch1);// F                  char china = '家';         System.out.println('家' + 0);// 23478                  System.out.println((char)23478);// 家 } }

 

 

1. 1. 字符串类型
2. 字符串类型使用String进行表示

   举例 : String s = “hello world”;

 

1. 字符串类型与任意数据类型相加(做加法),都表示字符串的拼接, 结果仍然还是一个字符串类型

 

代码

package com.ujiuye.variable; public class Demo11_字符串类型 { public static void main(String[] args) {         // 1. 定义出一个字符串类型数据 String  s = "hello???"; // 字符串类型与任意数据类型相加(做加法),都表示字符串的拼接, 结果仍然还是一个字符串类型 String s1 = "6"; System.out.println(s1 + 5);// 65   // 1) "6" + 5 = "65"  2) "65" + 4 = "654" System.out.println(s1 + 5 + 4);// 654 // 1) (5 + 4) = 9  2) "6" + 9 = "69" System.out.println(s1 + (5 + 4));// 69 // 1) 5 + 4 = 9  2) 9 + "6" = "96" System.out.println(5 + 4 + s1);// 96 } }

 

 

1. 运算符
   1. 基本算数运算符

  +  -  *  /  %

 

1. + : 加法

1. 直接将+作用在数据之前,表示正数  +3 与 3等价
2. 做数值之间的加法运算  3 + 2 = 5;
3. 做字符串的加法拼接 :

1. - : 减法

1. 直接将 - 作用在数据之前, 表示负数  -3
2. 做数值之间的减法  3 - 2 = 1;

1. * : 乘法

   做数值之间的乘法运算 : 3 * 2 = 6;

1. / : 除法

1. 如果相除的两个数都是整数类型, 那么结果就是整数类型, 小数点全部舍掉
2. 如果相除的两个数中,全部或者有其中一个为浮点类型, 那么结果就是浮点类型

 

1. % : 取模运算(取余运算)

   两数相除, 获取到余数

   5 % 2 = 5 / 2 = 2...1    结果1

 

1. 取余运算结果也具有符号位 : 与%前面的数据符号保持一致
2. 取余运算的使用场景 : 做数据筛选

   需求 : 定义出任意一个正整数, 判断这个数是奇数还是偶数

   分析 : 能被2整除的数就是偶数, 整除就是相除没有余数

      int i = 9;

      i % 2 取模的结果是不是等于0 ----> 如果等于0,偶数; 否则就是奇数

 

代码

package com.ujiuye.cal; public class Demo12_基本算数运算符 { public static void main(String[] args) {         // 1. + System.out.println(+3);// 3 System.out.println(3 + 2);// 5 System.out.println("hello" + 5);// hello5   // 2. - System.out.println(-2);// -2 System.out.println(3 - 2);// 1   // 3. * System.out.println(3 * 2);// 6   // 4. / System.out.println(5 / 2);// 2 System.out.println(5.0 / 2);// 2.5 System.out.println(5 / 2.0);// 2.5 System.out.println(3.0 / 2.0);// 1.5   // 5. % : 两数相除, 获取到余数 System.out.println(5 % 2);// 1   System.out.println(7 % 10);// 7 // 1) 与%前面的数据符号保持一致 System.out.println(-7 % 2);// -7 % 2 = -3...-1 } }

 

 

1. 1. 自增自减运算符
2. ++ : 自增运算符 : 作用在变量之上, 让变量本身值+1
3. -- : 自减运算符 : 作用在变量之上, 让变量本身值-1

 

1. 自增自减运算符的运算过程: int i = 10;

1. ++或者--直接作用在变量之上, 且++i或者i++作为独立的表达式,那么++或者--作用在变量前或者是变量后,效果一致, 都是让变量i本身的值+1或者-1
2. ++或者--直接作用在变量之上, 变量同时参与运算(不是独立表达式)

   a : 如果++或者--作用在变量之前, 先进行变量本身的自增或者自减, 再使用变化后的变量数据参与运算

   b : 如果++或者--作用在变量之后, 那么先使用变量的原值进行运算, 运算完毕, 再进行变量本身的自增或者自减

 

代码

package com.ujiuye.cal; public class Demo13_自增自减运算符 { public static void main(String[] args) {          int i = 10;          // i++作为一个独立表达式          i++;          System.out.println(i);// 11          // ++i作为一个独立表达式          ++i;          System.out.println(i);// 12                    --i;          System.out.println(i);// 11                    i--;          System.out.println(i);// 10                    System.out.println("------------");                   // a : 如果++或者--作用在变量之前, 先进行变量本身的自增或者自减, 再使用变化后的变量数据参与运算          int y = 20;          // 1) ++i  i = 11          // 2) i + y = 11 + 20 = 31 --->w          int w = ++i + y;          System.out.println(w);// 31          System.out.println(i);// 11                    System.out.println("+++++++++++++++");                    // b : 如果++或者--作用在变量之后, 那么先使用变量的原值进行运算, 运算完毕, 再进行变量本身的自增或者自减          // 1) 使用i的原值参数运算  i = 11          // 2) ++y  y = 21          // 3) 11 + 21 = 32 ---> result          // 4) i--  i = 10          int result = i-- + ++y;          System.out.println(result);// 32          System.out.println(i);// 10          System.out.println(y);// 21 } }

附加案例

package com.ujiuye.cal; public class DemoTest { public static void main(String[] args) {          int i = 10;          int j = 20;          int w = i+++j;// 这行代码如何拆解 i++ + j          System.out.println(w);// 30          System.out.println(i);// 11          System.out.println(j);// 20 } }