小白艰苦学习之路（记录学习历程——Java篇）Day3

于 2021-06-17 19:41:51 发布
阅读量156 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TinkerHua/article/details/118000287
版权
这篇博客主要介绍了Java中的数据类型扩展，包括整数、浮点数、字符和布尔值。讨论了类型转换，强调了强类型语言的特点和转换注意事项。此外，还涵盖了变量、作用域、常量、运算符（如二元运算符、关系运算符、自增自减运算符、位运算符）以及包机制和JavaDoc生成文档的基本知识。
摘要由CSDN通过智能技术生成

Day3

数据类型扩展及面试题讲解

整数拓展

public class Test1{
     public static void main(String[] args){
         //进制：二进制0b  十进制  八进制0  十六进制0x
         int i1 = 0b1010;//二进制
         int i2 = 100;
         int i3 = 010;//八进制
         int i4 = 0x10;//十六进制
         System.out.println(i1);
         System.out.println(i2);
         System.out.println(i3);
         System.out.println(i4);
     }
 }

运行结果图

浮点数拓展

 public class Test1 {
     public static void main(String[] args) {
         //浮点数   银行业务如何表示
         //BigDecimal 数学工具类 完成
         //float     有限 离散 舍入误差 大约 接近但不等于
         //double
         //最好完全避免使用浮点数进行比较
         float f = 0.1f;
         double d = 0.1;
         System.out.println(f==d);//false
 ​
         float f1 = 11111111111111f;
         double d1 = f1 + 1;
         System.out.println(f1==d1);//true
     }
 }

注：最好完全避免使用浮点数进行比较

运行结果图

字符拓展

 public class Test1 {
     public static void main(String[] args) {
         char c1 = 'A';
         char c2 = '中';
         System.out.println(c1);
         System.out.println((int)c1);//强制转换
         System.out.println(c2);
         System.out.println((int)c2);//强制转换
         //所有的字符本质还是数字
         //编码 Unicode 表 2字节 65536 Excle：2 16 = 65536
         char c3 = '\u0061';
         System.out.println(c3);//a
     }
 }

注：所有的字符本质还是数字

运行结果图

转义字符

 public class Test1 {
     public static void main(String[] args) {
         //转义字符
         // \t 制表符
         // \n换行符
         System.out.println("Hello\tWorld");
         System.out.println("Hello\nWorld");
     }
 }

运行结果图

布尔值扩展（新手老手的区别）

 //布尔值扩展
 boolean flag = true;
 if(flag==true){}//新手
 if (flag){}//老手

类型转换

  • Java是强类型语言，所以在进行某些运算的时候，需要用到类型转换

    低------------------------------------------------------------>高

    byte,short,char—>int—>long—>float—>double

  • 运算中，不同类型的数据类型先转化为同一类型，然后进行运算

  • 强制类型转换

     public class Test2 {
     public static void main(String[] args) {
         //强制类型转换    (类型)变量名  高—>低
         int i = 128;
         byte b = (byte)i;//内存溢出
         System.out.println(b);
     }
 }

  • 自动类型转换

     public class Test2 {
     public static void main(String[] args) {
         //自动类型转换    低—>高
         double d = i;
         System.out.println(d);
     }
 }

运行结果图

注意点：

  1. 不能对布尔值进行转换

  2. 不能吧对象类型转换为不相干类型

  3. 在把大高容量转换为低容量时，强制转换

  4. 转换的时候可能存在内存溢出，或精度问题

操作比较大的数时，注意溢出问题

 public class Test3 {
     public static void main(String[] args) {
         //操作比较大的数时，注意溢出问题
         //JDK7新特性，数字之间可以用下划线分割
         int money = 10_0000_0000;
         int years = 20;
         //int total = money*years;//-1474836480,计算的时候溢出了
         //long total = money*years;//默认是int，转换之前已经存在问题了
         
         long total = money*((long)years);
         System.out.println(total);
     }
 }

变量

  • 变量：可以变化的量

  • Java是一种强制类型语言，每个变量都必须声明其类型

  • Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

     type varName [=value] [{,varName[=value]}];
 //数据类型 变量名 = 值；可以用都好隔开来声明多个同类型变量

  • 注意事项：

    • 每个变量都有类型，类型可以为基本类型，也可以为引用类型

    • 变量名必须是合法的标识符

    • 变量声明是一条完整的语句，因此每一个声声慢都必须以分号结束

变量作用域

  • 类变量

  • 实例变量

  • 局部变量

注：

  • 实例变量：从属于对象，如若不初始化，则会变成这个类型的默认值

  • 基本类型 默认值为：0 0.0

  • 布尔值 默认值为：false

  • 除了基本类型其余都为null

  • 局部变量：必须声明和初始化值

  • 类变量 ：static 从属于这个类，随着类出现，随着类消失

 public class Test4 {
 ​
     //类变量  static 从属于这个类，随着类出现，随着类消失
     static double salary = 2500;
     //属性：变量
 ​
     //实例变量 从属于对象，如若不初始化，则会变成这个类型的默认值
     //基本类型 默认值为：0 0.0
     //布尔值 默认值为：false
     //除了基本类型其余都为null
     String name;
     int age;
 ​
     // main方法
     public static void main(String[] args) {
 ​
         //局部变量 必须声明和初始化值
         int i = 10;
         System.out.println(i);
 ​
         new Test4();
         Test4 test4 = new Test4();//变量类型 变量名 = new Test4();
         System.out.println(test4.age);
         System.out.println(test4.name);
         
         //类变量  static
         System.out.println(salary);
 ​
     }
 ​
     //其他方法
     public void add(){
 ​
     }
 ​
 }

常量

  • 常量（Constant）：初始化（initialize）后不能再改变值，不会变动的值

  • 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中，不允许被改变

    final 常量名 = 值；

    final double PI = 3.14；

  • 常量名一般使用大写字符

 public class Test5 {
     
     //修饰符 不存在先后顺序 static和final不存在先后顺序
     static final double PI = 3.14;
 ​
     public static void main(String[] args) {
         System.out.println(PI);
     }
 }

变量的命名规范

运算符

二元运算符

 public class Test6 {
     public static void main(String[] args) {
         //二元运算符
         //Ctrl+D 复制当前行到下一行
         int a = 10;
         int b = 10;
         int c = 10;
         int d = 10;
         System.out.println(a+b);
         System.out.println(a-b);
         System.out.println(a*b);
         System.out.println(a/(double)b);
 ​
     }
 }

【几个基本类型相加，有long则输出为long，有double则输出为double】

 package base;
 ​
 public class Test7 {
     public static void main(String[] args) {
         long a = 12312252233L;
         int b = 123;
         short c = 10;
         byte d = 8;
         System.out.println(a+b+c+d);//long
         System.out.println(b+c+d);//int
         System.out.println(c+d);//int
     }
 }

关系运算符

public class Test8 {
     public static void main(String[] args) {
         //关系运算符返回的结果：正确/错误 结果为布尔值
         int a = 10;
         int b = 20;
         int c = 21;
 ​
         System.out.println(c%b);
         System.out.println(a>b);
         System.out.println(a<b);
         System.out.println(a==b);
         System.out.println(a!=b);
 ​
     }
 }

自增自减运算符、初识Math类

自增：++

 int a = 3;
 int b = a++;//先给b赋值，再自增
 int a = 3;
 int b = ++a;//先自增，再给b赋值

自减：--（与自增一致）

幂运算(很多运算，我们会使用一些工具类进行操作)

 double pow = Math.pow(2,3);//2^3

逻辑运算符

 public class test1 {
     public static void main(String[] args) {
         //逻辑运算
         //与或非
         boolean a = true;
         boolean b = false;
         System.out.println("a && b:"+(a&&b));//逻辑与运算：同真为真
         System.out.println("a || b:"+(a||b));//逻辑或运算：一真为真
         System.out.println("a && b:"+!(a&&b));//逻辑非运算：真假相反
         //短路运算
         int c = 4;
         boolean d = (c<5)&&(c++<4);
         System.out.println(c);
         System.out.println(d);
     }
 }

运行结果图

位运算符

与或非

A = 0011 1100

B = 0000 1101

A&B = 0000 1100 //与运算：相同保留，不同为0

A|B = 0011 1101 //或运算：相同保留，有1为1

A^B = 0011 0001 //异或运算：相同为0，不同为1

~B = 1111 0011 //非运算：与运算取反

左移右移

<< >>

  • << *2

  • >> /2

扩展运算符

 int a = 20;
 a+=b;//a = a+b
 a-=b;//a = a-b

字符串连接符 +

 int a = 10;
 int b = 20;
 //若出现字符串在前，则后面的数会被变成字符串进行拼接，若字符串在后，则不会变成字符串进行拼接
 System.out.println(""+a+b);//输出为：1020
 System.out.println(a+b+"");//输出为：30

三元运算符

x ? y : z

如果x==true，则结果为y，否则为z

 public class Test2 {
     public static void main(String[] args) {
         int score = 50;
         String type = score < 60 ? "不及格" : "及格";//必须掌握
         System.out.println(type);
     }
 }

运行结果图

优先级 ()

包机制

  • 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间

  • 包语句的语法格式为：

     package pkg1[.pkg2[.pkg3...]];

  • 一般利用公司域名倒置作为包名 eg:com.Hua.operator

  • 为了能使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句即可完成

     import package1[.package2...].(classname|*);
 //import com.Hua.*; 导入所有的

【推荐：阿里巴巴开发手册】

JavaDoc生成文档

如何使用IDEA生成Doc文档

  1. 在IDEA中打开如下目录

     

  2. 在这里选择创建Doc文档的文件夹位置

     

  3. 在Local行和编码集写下如下代码，即可设置为中文且防止了中文带来的乱码

     

  4. 击"ok"后IDEA便会自动生成JavaDoc文档

花子柒
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值