JAVA语言

最新推荐文章于 2022-12-28 23:00:51 发布

Mr_LLeon

最新推荐文章于 2022-12-28 23:00:51 发布

阅读量257

点赞数

本文链接：https://blog.csdn.net/LLeonTT/article/details/113842567

版权

工作之余将自己的知识进行了详细化的整理，希望能够帮助有需要的朋友。

JAVA语言概述

①JAVA SE称之为java平台标准版，是java平台的基础,JAVA SE包含了运行java应用所需要的基础环境和核心类库,JAVA SE还定义了基于桌面应用的基础类库，通过使用这些类库，我们可以编写出类似于像Office那样的丰富多彩的桌面应用。
②JAVA EE称之为java平台企业版,JAVA EE构建在jave se基础之上，用于构建企业级应用。所谓企业及应用是指那些为商业组织、大型企业而创建的应用系统，例如：电信的"计费系统"，银行的"网银系统"，企业中的"客户关系管理系统"等等。

开发环境的搭建和使用

JDK_11 称为java开发工具包，开发需要下载和安装jdk。
JRE 称为java se运行时环境，提供了运行java应用程序所必须的软件环境等，无论是开发还是运行java应用都必须安装（客户需要安装jre，只需要能正常运行java程序就行）。
bin目录：该目录下主要存放JDK的各种工具命令
conf目录：该目录下主要存放jdk的相关配置文件
include目录：该目录下主要存放了一些平台的头文件
jmods目录：该目录下主要存放jdk的各种模块
legal目录：该目录下主要存放jdk各模块的授权文档
lib目录：该目录下主要存放了jdk工具的一些补充jar包和源代码
在使用Windows系统的dos命令窗口时，现将代码编写到文本中保存为java类型文件，
javac.exe 编译器，主要用于将高级java源代码翻译成字节码文件。（将源代码(我们编写的代码)翻译成字节，码也就是.class文件）
java.exe 解释器，主要用于启动jvm（java虚拟机）对字节码文件进行解释并执行。
在这里插入图片描述
JAVA的跨平台原理：Java字节码可以通过JVM翻译为具体平台能够执行的机器指令，由于Sun定义了JVM规范，而且不同的操作系统大多提供了JVM实现，才使得相同的一个字节码文件可以在不同的系统上运行，从而使Java赢得了一次编译，到处使用的编译。

常用的进制

在日常生活中采用十进制进行数据的描述，逢十进一，十进制的权重为：10⁰、10¹、10²……
在计算机的底层采用0和1组成的二进制序列进行数据的描述，逢二进一，二进制的权重为：2⁰、 2¹、 2²……
二进制中的最高位（最左边）用于代表符号位，若该位是0则表示非负数，若该位是1则表示负数。

进制之间的转换

正十进制转换为二进制的方式：
A.除2取余法：使用十进制整数不断地除以2取余数，直到商为0时将余数逆序排序。
45转换为2进制为10 1101 或者0b10 1101
45/2=22（余数1）
22/2=11（余数0）
11/2=5 （余数1）
5/2=2 （余数1）
2/2=1 （余数0）
1/2=0 （余数1）
然后将余数倒过来写，即：10 1101
B.拆分法：将十进制整数拆分为若干个二进制权重的和，有该权重下面写1，否则写0.
0 0 1 0 1 1 0 1
。。。 128 64 32 16 8 4 2 1
45 = 32 + 8 + 4 + 1
正二进制转换为十进制的方式：
A.加权法，使用二进制中每个数字乘以当前位的权重在累加起来。
二进制0010 1101转换为十进制的结果为：
0 * 2⁷+0 * 2⁶+1 * 2⁵+0 * 2⁴+1 * 2³+1 * 2²+0 * 2¹+1 * 2⁰
负十进制转换为二进制的方式：
①先求出负十进制的绝对值，并先求出相对应的二进制，然后按位取反，最后再在末尾加1。
十进制-45转换为二进制的结果为：
十进制绝对值45转换为二进制：0010 1101
按位取反：1101 0010
再加1：1101 0011
负的二进制转换为十进制的方式：
①先将二进制减1再按位取反，合并为十进制整数后添加负号。
负二进制1101 0011转换为十进制的结果是：
先减1：1101 0010
按位取反：0010 1101
转为十进制：-45
单个字节表示的整数范围：
在计算机中单个字节表示八位二进制位，其中最高位（最左边）代表符号位，使用0代表非负数，使用1代表负数，具体表示的整数范围如下：
非负数所能表示的整数范围：0000 0000~0111 1111 0~127
0 * 2⁷+1 * 2⁶+…+1 * 2¹+1 * 2⁰=127
负数所能表示的整数范围：1000 0000~1111 1111 -128~-1
整数-128在计算机中如何表示
1、先取128的原码：1000 0000
2、得反码： 0111 1111
3、得补码： 1000 0000
整数-1在计算机中如何表示
1、先取1的原码：0000 0001
2、得反码：1111 1110
3、得补码：1111 1111
综上所述：
单个字节表示的整数范围：-128~127

变量和数据类型

变量的基本概念：当需要在程序中记录单个数据内容时，则声明一个变量即可，而声明变量的本质就是在内存中申请一个存储单元，由于该存储单元中的数据内容可以发生改变，因此称为变量。
由于存放的数据内容大小不一样，导致所需存储单元的大小不一样，在Java中使用数据类型加以描述，为了便于下次访问还需要给该变量指定一个名字，用于记录该变量对应的存储单元。

变量的声明方式

数据类型变量名=初始值;
其中变量不能重复声明，int不能使用大写，String类型要进行大写。

标识符的命名法则

由数字、字母、下划线、$等组成，其中数字不能开头。不能使用java语言的关键字，所谓关键字就是java语言用于表示特殊含义的单词。区分大小写，长度没限制，但不宜过长。标识符可以给类、变量、属性、方法、包起名。

import java.util.Scanner;
public class VarIOTest{
   public static void main(String[] args){
//声明两个变量
      int Age;  //相当于先占个位置
      String Name;  相当于先占个位置
   System.out.printin("请输入你的年龄和名字：");
//创建一个扫描器来扫描键盘输入的内容，随时用随时声明
   Scanner sc = new Scanner(System.in);
      Name = sc.next();
      Age = sc.nextInt();
   System.out.println("Age="+Age);
   System.out.println("Name="+Name);   
   System.out.println("Name="+Name + "Age="+Age);
} 
}

数据类型的分类

数据类型的分类
1、基本类型（记住）
Byte、short、int、long、float、double、boolean、char
2、引用数据类型
数组、类、接口、枚举、标注
整数类型：
其中byte类型在内存空间占1(18=8-1)个字节，表示范围是：-2⁷~2⁷-1
其中short类型内存空间占2(28=16-1)个字节，表示范围是：-2¹⁵~2¹⁵-1
其中int类型在内存空间占4(48=32-1)个字节，表示范围是：-2³¹~2³¹-1
其中long类型在内存空间占8(88=64-1)个字节，表示范围是：-2⁶³~2⁶³-1

public class IntTest{
   public static void main(String[] args){
      //1、声明一个byte类型的变量并初始化   
      byte b1= 25;   //超过范围会报错   若描述比long类型还大的数据则使用java.math.BigInteger类型
     //2、打印变量数值
   System.out.println("b1 = "+b1);
      int i2 = 25;
      byte b2 = i2;//因为i2是变量有可能转变。所以不行，会报错
}
}

浮点类型：
java语言中用于描述小数数据的类型：float、double，推荐double类型。
其中float类型在内存空间占4个字节，叫做单精度浮点数，可以表示7位有效数字，范围：-3.403E38~3.403E38。
其中double类型在内存空间占8个字节，叫做单精度浮点数，可以表示15位有效数字，范围：-1.798E308~1.798E308。

public class DoubleTest{
   public static void main(String[] args){
      //1、声明一个float类型
      float f1 = 3.1415926f;//从double转换为float可能会有损失，小数数据叫做直接量，默认为double类型。
   System.out.println("f1 = "+ f1);//一般是7位有效数字
      double d1 = 3.1415926;
   System.out.println("d1 = "+ d1);//一般是15位有效数字
} 
}

布尔类型：
java语言中用于描述真假信息类型有：boolean,数值只有：true和false

public class BooleanTest{
   public static void main(String[] args){
      boolean b1 =  true;
   System.out.println("b1 = "+b1);
}
}

字符类型：
java语言中用于描述单个字符的数据类型：char类型。如：’a‘，’中‘等。
其中char类型在内存空间中占2个字节并且没有符号位，表示的范围是：0~65535，由于现实生活中很少有数据能被单个字符描述，因此以后的开发中更多的使用多个字符串起来组成字符串，使用string类型加以描述，如：’hello‘，’中国‘等。
计算机的底层只识别0和1组成的二进制序列，对于字符’a‘这样的图案来说不满足改规则，因此该数据无法直接在计算机中存储，但现实生活中存在这样的图案数据需要计算机存储，为了使得该数据能够存储起来就可以给该数据定一个编号，然后将编号存储起来即可，该编号就叫做ASCⅡ。
‘0’-48 ‘A’-65 ‘a’-97 ‘空格’-32 ‘换行符’-10

public class CharTest{
   public static void main(String[] args){
      //1、声明一个char类型变量并初始化
      char c1 = ‘a’;
      //2、打印变量的值
   System.out.println("c1 = "+ c1);//c1=a
   System.out.println("对应的编号是："+ (int)c1);//表示将char类型的c1强制转换为int类型c1=97 
      //2、声明一个char类型的变量并初始化
      char c2 = 98;
    System.out.println("c2 = "+ c2);//c2 = b
    System.out.println("对应的编号是："+ (int)c2);//98
      //3、使用unioncode字符集来表示名字，奇点对应的编号是：\u5947\u70b9
      char c3 = ‘\u5947’;
      char c4 = ‘\u5947’;
   System.out.printlnI("最终结果是："+ c3 + c4);//奇点
}
}

基本数据类型之间的转换：
java语言中基本数据类型之间的转换方式：自动类型转换和强制类型转换。
其中自动类型转换主要是指从小类型到大类型之间的类型。
byte—>short—>int—>long—>float—>double
char
1 2 4 8 4 8
其中强制类型转换主要指从大类型到小类型之间的转换，语法格式如下：
目标类型变量 = （目标类型）源类型变量名；

//编程实现基本数据类型之间转换的使用
pablic class TransformTest{
  public static void main(String[] args){
   //1、声明两个变量并初始化
   byte b1 = 10;
   short s1 = 20;
   //2、打印变量的数值
  System.out.println("b1 = " + b1);
  System.out.println("s1 = " + s1);
   //3、实现自动类型之间的转换，表示将变量b1的数值赋值给变量s1，并覆盖变量s1中原来的数值，相当于从byte类型转换到short类型的转换，小到大的转换。
   s1 = b1;
  System.out.println("b1 = " + b1);  //b1=10
  System.out.println("s1 = " + s1);  //s1=10
  //4、实现强制类型之间的转换，表示将变量s1的数值赋值给变量b1，并覆盖变量b1中原来的数值，相当于从short类型到byte类型的转换，大到小的转换。
   b1 = (byte)s1;
   b1 = s1;//不兼容类型，从short到byte可能会损失。
  System.out.println("b1 = " + b1);  //b1=10
  System.out.println("s1 = " + s1);  //s1=10
}
}

算术运算符的概念和使用

算术运算符：+ - * / %(表示取余)

/*
  编程实现算术运算符的使用
*/
public class ArithemticTest{
   public static void main(String[] args){
      int ia = 6;
      int ib = 2; 
      int ic;
   System.out.println("ia+ib="+ (ia+ib));
   System.out.println("ia-ib="+ (ia-ib));
   System.out.println("ia*ib="+ ia*ib);
   System.out.println(ia+ib);
   System.out.println(ia-ib);
   System.out.println(ia*ib);
   System.out.println(ia/ib);
   System.out.println(ia%ib);
   System.out.println(5/2);//只能出现整数
   System.out.println((double)5/2);
   System.out.println(5*1.0/2);//让其中一个数乘以1.0
}
}

/*
输入一个正整数的秒数，拆分成xx时xx分xx秒
*/
import java.util.Scanner;
public class SecondTest{
    public static void main(String [ ] args){
    System.out.printin("输入一个正整数秒数：");
    Scanner sc = new Scanner(System.in);
       int num = sc.nextInt();
       int hour = num / 3600;//小时数
       int min = num % 3600 / 60;//分钟数
       int sec = num % 60;//秒数
     System.out.println(num + "秒转换为" + hour + "小时" + min + "分钟" + sec + "秒钟")//只要+两边的操作数中有一个操作数是字符串类型，则该+就被当做字符串连接处理，否则当做加法运算符处理。
}
}

关系/比较运算符

>表示是否大于运算符 >=表示是否大于等于运算符
<表示是否小于运算符 <=表示是否小于等于运算符
==表示是否等于运算符 !=表示是否不等于运算符
++表示自增运算符，用于使得当前自身变量的数值加1 的效果；
--表示自减运算符，用于使得当前自身变量的数值减1的效果；

public class SelfTest{
   public static void main(String[] args){
      int ia = 10;
   System.out.println("ia = "+ ia);//10
      ia++;
   System.out.println("ia = "+ ia);//11
      ++ia;
System.out.println("ia = "+ ia);//12
}
}

其中a++这个整体叫做表达式其中ia叫做操作数/变量也就是ia++和ia表示不同的含义，因此所占的内存空间应该不同。

public class FormHindTest{
   public static void main(String[] args){
       ia = 10;
       ib = 10;
//后++表示先让变量的数值作为整个表达式的最终结果，然后让ia变量自身的数值加1
   System.out.println(ia++);//10
   System.out.println("ia = "+ ia);//11
//前++表示先让变量自身的数值加1，然后再让变量的数值作为整个表达式的结果。
   System.out.println(++ia);//12
   System.out.println("ia = "+ ia);//12
   System.out.println("ib = "+ ib);
   System.out.println( ib--);//10
   System.out.println("ib = "+ ib);//9
   System.out.println(--ia);//8
   System.out.println("ib = "+ ib);//8
       ia = 14;
   System.out.println(ia++ + ++ia);//14+16=30
   System.out.println("iba= " + ia);//16
}
}

逻辑运算符
&&表示：逻辑与运算符，相当于"并且"，同真为真，一假为假。
||表示：逻辑或运算符，相当于"或者"，一真为真，同假为假。
！表示：逻辑非运算符，相当于"取反"，为真为假，假为真。
逻辑运算符的操作数均为bollean表达式。

/*
 编程实现逻辑运算符的使用
*/
public class LogicTest{
   public static void main(String[] args){
        boolean b1 = true;
        boolean b2 = false;
   System.out.println("b1 = " + b1);//true
   System.out.println("b2 = " + b2);//false
        boolean b3 = b1 && b2;
   System.out.println("b3 = " + b3);//false
   System.out.println(b1 && b2);//false
   System.out.println(b1 || b2);//true
   System.out.println(!b2);//true
}
}

逻辑运算符的短路特性
对于逻辑与运算符来说，若第一个表达式为假则结果为假，此时跳过第二个表达式。
对于逻辑或运算符来说，若第一个表达式为真则结果为真，此时跳过第二个表达式。

public class LogicTest{
    public static void main(String[] args){
        int ia = 3;
        int ib = 5;
        Boolean b4 = (++a == 3) && (++ib == 5); 
    System.out.println("b4 = " + b4);//false
    System.out.println("ia =" + ia);//4
  System.out.println("ib =" + ib);//5
}
}

逻辑运算符判断三位数
提示用户输入一个正整数，使用逻辑运算符判断该正整数是否为三位数，若是则打印true，否则打印false

import java.util.Scanner;
public class LogicJudgeTest{
     public static void main(String[] args){
         //1、提示用户输入一个正整数
        System.out.println("请输入一个正整数");
        Scanner sc = new Scanner(System.in);
        int num = sc.nextInt();
        //2、使用逻辑运算符判断该正整数是否为三位数并打印
System.out.println(100 <= num && num <= 999);
}
}

条件/三目运算符
条件表达式？表达式1:表达式2
判断条件表达式是否成立，若成立则执行表达式1，否则执行表达式2。

import java.util.Scanner;
public class LogicJudgeTest{
     public static void main(String[] args){
         //1、提示用户输入一个正整数
         System.out.println("请输入一个正整数");
         Scanner sc = new Scanner(System.in);
         int num = sc.nextInt();
         //2、使用逻辑运算符判断该正整数是否为三位数并打印
    System.out.println(num + ((100 <= num && num <= 999)?"是三位数":"不是三位数"));
}
}

//提示用户输入两个整数，使用三目运算符找到最大值并打印
/*
使用三目运算符找到最大值
*/
import java.util.Scanner;
public class ThreeEyeTest{
   public static void main(String[] args){
       //1、提示用户输入两个整数并用变量记录
     System.out.println("输入两个整数");
     Scanner sc = new Scanner(System.in);
      int ia = sc.nextInt();
      int ib = sc.nextInt(); 
       //2、使用三目运算符找到最大值并打印
      int max = ia > ib? ia : ib;
     System.out.println("最大值是：" + max);
  System.out.println("最大值是：" + (ia > ib? ia : ib));
}
}
/*
赋值运算符的使用
*/
public class AssignTest{
   public static void main(String[] args){
       //1、声明一个int类型的变量并初始化
      int ia = 3;
     System.out.println("ia = " + ia);//ia = 3
      //2、简单赋值运算符的使用
      ia = 5;//表示将数据5赋值给变量ia，并且覆盖变量ia原来的数值。
     System.out.println("-------------------------------")
     //3、复合赋值运算符的使用
      ia = ia +2;
     //简化
      ia += 2;
    System.out.println("ia = " + ia);
      byte b1 = 10;
    System.out.println("b1 = " + b1);//10
      b1 = b1 + 2;//错误：不兼容的类型，从int转换到byte可能会有所损失（byte + int相加结果还是int类型）
      b1 = b1 + (byte)2;//错误：不兼容的类型，从int转换到byte可能会有所损失（byte + byte相加结果还是int类型）
      b1 = (byte)(b1 + 2);//强制转换类型，将int类型转换为byte类型b1 += 2;
    System.out.println("b1 = " + b1);//12
    //笔试考点
      ia == 2;//表示判断变量ia的数值是否等于2。
      2 == ia;//表示判断2是否等于变量ia的数值。
      ia = 2;//表示将2赋值给变量ia，覆盖变量ia原来的数值。
      2 = ia;//编译错误，将数值赋值给变量而不是将变量赋值给数值。
} 
}

移位运算符:
<<左移运算符，用于将数据的二进制位向左移动，右边使用0补充
>>右移运算符，用于将数据的二进制位向右移动，左边使用符号位补充
>>>表示逻辑右移运算符，用于将数据的二进制位向右移动，左边使用0补充

/*
移位运算符的使用
*/
public class MoveBitTest{
   public static void main(String[] args){
       //1、声明一个byte类型的变量并初始化
        byte b1 = 13;
     System.out.println("b1 = " + b1);//b1=13
       //2、移位运算符的使用//13的二进制是:0000 1101 ---》左移1位的结果是 0001 1010 ---》换算为十进制:26
        byte b2 = b1 << 1;//将b1的二进制位向左移1位。//错误，不兼容的类型，从int转换到byte可能会有所损失，因为（b1 << 1）为int类型,自动提升为int类型，32位二进制二进制。
        byte b2 = (byte)(b1 << 1);
    System.out.println("b2 = " + b2);//26
    System.out.println(b1 << 1);//26  左移1位相当于当前整数的数值*2
    System.out.println(b1 << 2);//52  左移1位相当于当前整数的数值*4//13的二进制是:0000 1101 ---》右移1位的结果是0000 0110---》换算为十进制:6
    System.out.println(b1 >> 1);//6  右移1位相当于当前整数的数值/2
    System.out.println(b1 >> 2);//3  右移1位相当于当前整数的数值/4//逻辑右移  对于非负数来说，逻辑右移和右移的效果一致
    System.out.println(b1 >>> 2);//3
}
}

位运算符
&表示按位与运算符，按照二进制位进行与运算，同1位1，一0为0。
|表示按位或运算符，按照二进制位进行或运算，一1为1，同0为0。
~表示按位取反运算符，按照二进制位进行取反，1为0，0为1。
^表示按位异或运算符，按照二进制位进行异或运算，同为0，不同为1。

public class BitTest{
     public static void main(String[] args){
          //1、声明两个byet类型的变量并初始化
          byte b1 = 11;
          byte b2 = 12;
          //2、打印变量的数值
      System.out.println("b1 =" + b1);//11
      System.out.println("b2 =" + b2);//12
          //3、实现位运算符的使用
          //b1的二进制为:0000 1011         
          //b2的二进制位:0000 1101
      System.out.println(b1 & b2);//按位与 按位与后的二进制为:0000 1001 --->十进制:9
      System.out.println(b1 | b2);//按位或 按位或后的二进制为:0000 1111 --->十进制:15
      System.out.println(b1 ^ b2);//按位异或 按位异或后的二进制为:0000 0110 --->十进制:6
      System.out.println(~b1);//按位取反 按位取反后的二进制为:1111 0100 
                              //负的二进制1111 0100转为十进制--->先减1: 1111 0011
                              //最后一个0不够往倒数第二个0借
                              //倒数第二个0不够往倒数第三个借
                              //倒数第三个数为1，被借后变成0，倒数第二个则变成了2，
                              //往后借一个变成了1。所以最后为:1111 0011。--->转为十进制:12 添加负号:-12
}
}

今天的总结就到这了，下期将会整理出java语言的各种分支语句。

Mr_LLeon

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
JAVA语言

工作之余将自己的知识进行了详细化的整理，希望能够帮助有需要的朋友。JAVA语言概述 ①JAVA SE称之为java平台标准版，是java平台的基础,JAVA SE包含了运行java应用所需要的基础环境和核心类库,JAVA SE还定义了基于桌面应用的基础类库，通过使用这些类库，我们可以编写出类似于像Office那样的丰富多彩的桌面应用。 ②JAVA EE称之为java平台企业版,JAVA EE构建在jave se基础之上，用于构建企业级应用。所谓企业及应用是指那些为商业组织、大型企业而创建的应用
复制链接

扫一扫