javaSE---基础语法

1.初识JAVA----JAVA文件是怎么进行编译的

面试题：String[] args这个参数是干什么的？

args是运行时的命令行参数，在java HelloWorld后面加上一些参数，就会放在args的数组当中；

Windows系统上面的常见命令:

CMD:是在windows系统中，以命令行的方式来进行操作计算机的，可以打开文件，打开文件夹，创建文件夹等；

打开CMD:

1)先按下Win+R

2)输入CMD

3)按下回车键

常见的CMD命令:

1)盘符名称+冒号+回车进行切换盘符(这个冒号一定是英文)

2)dir查看当前目录下的内容

3)cd+目录名:进入到当前目录(和双击一个文件夹一样)

4)cd ..回退到上一级目录

5)cd/目录1/目录2

6)cd\回到盘符目录

7)cls进行清屏

8)exit推出窗口

9)nodepad打开记事本

10)calc打开计算器

JDK JVM以及JRE之间的关系:

1)JVM:叫做java虚拟机，是真正运行于Java程序的地方，没有Java虚拟机代码都没有地方运行

2)核心类库，就是Java已经写好的一些东西，我们直接拿过来用就可以了，比如说System，out，println，JAVA标准库中的一些类，运行代码的时候需要

3)还要有一些开发工具，比如说javac编译工具(.java文件编译成.class文件)，java运行工具，jdb调试工具

4)JDK，核心类库还有开发工具统称为JDK，所以说我们要进行安装JDK，JDK也被称为java开发工具包，又叫做java开发工具包，如果说我们要是想编写代码，就需要安装java开发工具包

5)JRE:又叫做java的运行环境，核心类库，还有运行工具(不会包含javac编译工具)，直接拿到编译好的.class文件的Java代码就可以运行了，这里是运行工具而不是什么编译工具(从开发工具里面把运行工具抽取出来)

6)JDK包含JRE，JRE包含着JVM

练习:我们通过CMD命令来打开QQ

1)我们需要先找到QQ的exe程序在文件夹里面的位置:右键点击QQ，选择属性，找到文件所在位置，就可以找到路径了,C:\Program Files (x86)\Tencent\QQ\Bin

 我们需要打开哪一个文件可以直接输入文件名就可以了，但是QQ是我们经常打开的软件，况且在每一次进行切换盘符，并且要进行进入多层文件夹，就太麻烦了

2)假设我们的QQ.exe文件是在D盘的，但是现在我们打开CMD命令之后看到的是C盘，我们如果说在CMD上面直接输入QQ.exe，那么下面会直接进行显示: 不是内部或外部命令，也不是可运行的程序
3)解决方案就是将QQ的路径给进行记录到电脑上的某一个地方，如果当前目录没有，我们就去这个地方去找，我们只需要把QQ的路径记录到环境变量里面

4)此电脑---->属性，搜索环境变量---->点击配置系统环境变量，在进行点击环境变量，点击系统变量里面的path，在进行点击编辑，新建，把QQ的路径放到这里面

配置环境变量:我们想要在任意的目录下想要打开指定的软件，我们就可以把软件的路径配置到环境变量里面

JDK文件夹的讲解:

1)bin:该路径下存放了很多工具命令，比如说javac和java

2)conf:提供了系统配置文件

1.通过写文件的方式来写java程序

编译:操作系统是不会认识Java代码的，所以我们要把Java语言翻译成操作系统可以看的懂的东西，所以说编译的动作就是翻译，就是将操作系统看不懂的内容翻译成操作系统可以看的懂的内容；javac就是JDK提供的编译工具

java也是JDK提供的一个工具，它的作用就是运行代码的，运行的是.class文件，但是当它运行的时候是不加后缀名的

1)我们在文件里面创建一个叫做HelloWorld.java的文件，里面写入java代码,我们这个文件直接是在D盘上面的(如果是在别的目录下，我们就需要进行切换盘符，找到我们的.java代码所在的文件位置)

2)打开CMD命令，切换到D盘，输入javac+HelloWorld.java,就可以进行编译Java文件里面的代码了，我们进行完这一步操作之后，就可以看到HelloWorld.class文件了，这就是编译生成的字节码文件

3)此时我们在进行输入java HelloWorld就可以运行咱们的程序了

但是我们此时发现了一个问题:javac和java这两个命令并没有配置在B盘里面的，那我们为什们还可以进行使用这两个命令呢？原因就是我在安装JDK的时候，系统已经自动把javac和java这两个文件给配置到环境变量里面了

4)此时我们还需要重新进行配置环境变量，因为java本身为我们进行配置的环境仅仅包含了4个工具，是不全的;

5)先在path外面新建，变量名写JAVA_HOME,下一个框里面写入路径

6)我们再进行配置path:%JAVA_HOME%\bin

Java在进行编译的时候，是按照GBK的方式来进行编译源码的，所以说如果.java文件里面出现了中文，就应该换成javac -encoding utf-8 HelloWorld.java

2.java的编译过程

.java程序，在源代码上，目前在磁盘上就是一大堆的代码，我们写的代码，目前只有我们自己认识，但是我们想要让编译器认识；不需要把这个文件进行编译，把他转化成计算机，编译器能够认识的东西，从而可以执行；编译以后会变成.class文件；

JVM:叫做java虚拟机，java程序就是跑在JVM里面,把对应的字节码文件拉取过来，然后进行执行

.java文件->会经过编译，javac命令，文件名是.java->.class文件(叫做字节码文件，二进制文件，包含了类中的信息)------>JVM(一个软件，C/C++写的)

javac HelloWorld.java先把.java文件编译成字节码文件，在命令行里面再进行输入java HelloWorld按一下回车就可以运行程序了

JDK里面包含着JRE，JRE里面包含着JVM；

注意：是一个类对应一个字节码文件，在执行到某个类的时候，用到哪个类，就加载某个类；

Java中的数据类型

1)变量指的是程序运行的时候可以改变的量，相当于是开辟一块内存空间来进行保存数据

2)类型是对变量的种类进行划分，不同类型的变量具有不同的特性

3)变量就是一个箱子，可以存放数据，有类型也有大小

常见的输入设备:键盘，麦克风

常见的输出设备:屏幕 

外存储器:磁盘，光盘，U盘，硬盘

内存储器:8G+256---->咱们的写的代码就存储在这里，跑起来的APP就越多

CPU=运算器(数据运算)+控制器(逻辑上的控制if判断)

字面值常量:什么时候输出的都是一个具体的值

什么是字节？

1)字节就是计算机中表示空间大小的基本单位，我们常用二进制来进行表示数据，那么就认为8个二进制位表示一个字节，我们平时所说的8GB内存，本质上说的就是8G个字节

2)那么int类型，4个字节，一个字节又表示8个二进制位，那么一个int类型的数据范围是32个二进制数据，的数据范围就是-2*2^31~2^31-1

bit byte kb mb gb tb pb

1 bit=8 byte，后面都是1024进位

重载：同一个方法名字，提供不同版本的实现，成为方法重载；但是当两个方法名字相同的时候，参数列表相同，返回值不同，不会构成重载；

1）方法名相同

2）方法的参数列表不同(参数个数或者是参数类型)

3）方法的返回值不做要求

  public static int add(int a,int b)
    {
        return a+b;
    }
    public static int add(int a,int b,int c)
    {
        return a+b+c;
    }
    public static  void add(int a,int b,int c,int d)
    {
        System.out.println(a+b+c+d);
    }
    public static void main(String[] args) {
     System.out.println(add(1,2));
     System.out.println(add(1,2,3));
     add(1,2,3,4);
    }

1)常量指的是运行时类型是不可以发生改变的，变量指的是运行时可以发生改变的量

2)在JAVA当中，每一种数值类型都是有范围的，存储数据的时候，不要超过最大范围

3)JAVA中的double虽然也是占8个字节，但是浮点数的内存布局和整数内存布局很大，因此不可以用2的多少次方来进行表示数据范围

1)int a=1.0;
int b=9.0;
//这样编译器直接会报错,因为double是8个字节,int是4个字节,double类型的变量不可以赋值给int
2)float a=8.0;//因为当你写8.0的时候,会被自动默认为是一个double类型的变量
 System.out.println(a);
//出现报错,因为默认a是一个double类型,所以系统会进行提示:java: 不兼容的类型: 从double转换到float可能会有损失
3)JAVA是一个强类型语言----在C语言里面,这样的结果顶多会进行警告
float a=8.0f-----表示是一个浮点类型的小数
4)double c=6.7f;
 System.out.println(c);-----可以运行通过

1)在java中，一个int变量占4个字节，所表示的范围在-2^31-2^31-1
我们要想查找int的最大值,最小值
 System.out.println(Integer.MAX_VALUE);
 System.out.println(Integer.MIN_VALUE);
2)long:长整型
long 变量名=初始值; long num=10L;
在java中,long类型占有8个字节，表示的数据范围在-2^63-2^63-1
 System.out.println(Long.MAX_VALUE);
 System.out.println(Long.MIN_VALUE);
3)双精度浮点型变量，小数是没有一个确切的数字的，他只能精确到几位
double 占8个字节
float 占4个字节
在java中，int/int的值仍然是int，如果想要得到0.5，就需要使用double来进行计算(1.0/2)来进行计算
4)char占2个字节，计算机中的字符本质上是一个整数，我们经常使用ASCLL来表示字符，在java中我们经常使用Unicode来表示字符，所表示的字符种类要更多，表示的范围是0-65535，是没有负数的

5)boolean占用1个字节

 char ch=97;
 System.out.println(ch);//此时打印的是a,就算你赋值的是一个整数,那么他最终打印的也是一个字符
 short a=90;//表述数据类型范围内-2^15-2^15-1
 byte c=90;//表示在数据范围内-128-127
 System.out.println(a);
 System.out.println(c);
上面都可以打印:
下面编译不通过:byte d=170;//错误
int a=(int)9090.0造成精度丢失的强制类型转换

 short a=128;
 byte b=(byte)a;//此时b的值就是127+1,这个时候又变成了-128

5)short变量，占用两个字节，-2^15-2^15-1
6)byte变量，占用一个字节，-128-127
7)boolean，true和false两种取值，没有明确的范围
注意:

1)double在任何系统之下都占8个字节

2)浮点数和整数在内存中的存储方式不同，不能单纯的用2^N来进行计算

3)浮点数类型的内存布局尝试使用有限的空间表示无限的小数，所以势必会存在一定的精度误差，因此浮点数是一个近似值，并不是一个精确的值

4)布尔类型不可以跟任何数据类型进行强制类型转换

注意:

1)不同数字类型的变量进行赋值的时候，表示范围更小的类型可以隐式的进行转换成范围比较大的类型

2)如果需要把范围大的类型赋值给范围小的类型，需要进行强制类型转换，但是可能会造成精度丢失

3)将一个字面值常量进行赋值的时候，JAVA会自动针对数字类型进行范围检查

4)强制类型转换不一定可以成功，不相干的类型不能进行强转

4.java中的类型转换:JAVA是一个强类型的语言，当不同类型的变量进行相互赋值的时候，就会有严格的校验，在JAVA中当参与运算的数据运算类型不一致的时候，就会进行类型转换，在JAVA中分为隐式类型转换和显式类型转换

自动类型转换是指:

1)代码不需要进行任何处理，在代码进行编译的时候，编译器会自动的进行处理，特点是数据范围小的转化为数据类型大的会自动进行转换

2)当我们使用字面值常量的时候进行赋值的时候，JAVA会自动的进行一些检查校验，判断赋值是否合理

比如说:System.out.println(1024)//默认情况下是int

System.out.println(129.90)//默认情况下是double

1)不同数字类型的变量相互赋值，表示范围小的类型可以转化成范围较大的类型，反之则不行；

int a=10;
long b=100L;
a=b;//编译错误,这么写就对了,因为long的范围比int类型的大,int的装不下long类型的数据,所以编译器认为这个操作不是安全的
a=(int)b;
b=a;//编译正确,相当于是隐式类型转换

小的数据类型不可以进行装大的类型的数据的 

float f=1.4f;
  double d=5.12;
  f=d;//此处编译会进行报错,因为f表示的数据类型的float,但是d表示的数据类型是double,float类型的数据类型是不可以进行存放double类型的数据的
  d=f;

int a=10;
long b=a;//long表示范围更大,可以将int复制给long
long c=90;
int b=c;//此时编译会不通过,因为提示可能会丢失精度
8个字节的数据强制向4个字节的类型存放,就会出现报错
因为本质上来说int类型的b是可以进行存放90这个数据的
但是b并不知道c的值具体有多大,你怎么就知道c等于90
万一c的值已经超过了b所能表示的范围呢?
//long  c=1111111L;
int a=c;//报错
int a=(int)c

1)long表示的范围更大，可以将int赋值给long，但是不能将long赋值给int

2)double表示的范围更大，但是可以将int赋值给double，但是不能将double赋值给int

 2)互不相关的两种类型，是不可以进行相互赋值的

    int a=10;
    boolean b=a;
    这里会提示编译出错,提示不兼容的类型

3)使用字面值常量赋值的时候，java会自动进行一些检查校验，判断赋值是否合理，byte a=127，编译通过；byte b=128，编译就会出错，已经超出范围，会提示从int转换到byte可能会有损失

byte a=10//编译通过
byte b=190//编译错误
byte b1=100;
byte b2=(byte)257;//编译错误

5.整型提升

1)int和long之间，int会被提升为long

int a=10;
long b=20;
int c=a+b;//编译出错,因为a+b=>int+long=>long+long这个时候传递给int类型的时候会造成丢失数据
long d=a+b;//编译成功,因为a+b=>int+long=>long+long结果还是long,最终成功赋值给了long

如果说最后想把结果真的赋值给int，有两种解决方法:在计算的过程中把a转成long类型，或者说把最终计算的结果强转成int类型，但是有可能会造成精度丢失

2)byte和byte的运算:当你参与运算的数据小于四个字节的时候，会进行提升，会把小于四个字节变成四个字节，如果我们此时想要用byte接受，应该进行强制类型转换，但是还可以用int来进行接收

1)不同的数据进行混合运算，范围小的会自动转换成范围大的类型

  int a=10;
    long b=20;
    int c=a+b;//编译出错
    long d=a+b;//编译成功
    int e=(int)(a+b);//编译成功
原因:当int和long进行混合运算,int会自动提升成long,所以得到的结果也是long类型,所以我们要用long类型的变量来接受结果(用int就会报错,因为大的类型不能赋值给小的类型，除非进行强制类型转换)

2)对于short和byte这种比4个字节小的类型，会优先转化成4个字节的int，再进行相加，也就是说，CPU在进行运算的时候，当自节小于4的时候，会自动提升成整形

   byte a=10;
   byte b=20;
   byte c=a+b;//编译报错,把四个字节的数据变成1个字节,int---->byte,必须进行强制类型转换
   byte d=(byte)(a+b);//编译成功
a b 都是byte类型，但是在进行a+b的运算的时候，会先提升类型为int,然后再进行相加运算,这是运算出的整体结果就是int,赋值给d时,byte类型就会出现报错;

  byte a=10;
  byte b=90;
  int c=a+b;
//这样就是正确的
byte c=10+20;//编译通过,因为10和20都是常量,在进行编译的过程中,已经被编译成3了
//但是下面就会报错:
byte a=10;
byte b=80;
byte c=10+80;//错误

 因为计算机的CPU通常是以4个字节为单位向内存中去读取数据，为了硬件实现方便，像short和byte这样的类型的数据，会优先提升成int

     System.out.println(11.5%3);
     System.out.println(10%3);
     System.out.println(10.0%3);
     System.out.println(10%3.0);
2.5
1
1.0
1.0
  System.out.println(-10%3);
  System.out.println(10%-3);
  System.out.println(-10%-3);
-1
1
-1
  System.out.println(-12.5%10.5);//最终下面的三种运算咱们取模的结果还是一个小数-2.0
  System.out.println(12.5%10.5);//2.0
  System.out.println(11%10.5);//0.5

   short a=10;
   short b=a+10;
   System.out.println(b);
//在这里面也会发生报错,也会发生整形提升

     short a=10;
        a+=9;
        System.out.println(a);//自动进行强制类型转换

1)关系运算符最后的值是一个boolean类型的值

2)表达式1||表达式2------>只要有一个表达式为真，整个表达式都是真，如果表达式1为真，那么表达式2就不会执行了

3)两类操作数类型不一致的时候，向类型大的进行提升，下面最终的结果会进行转化成Double类型

   System.out.println(1+0.2);

注意:下面这种情况:

int a=10;
double b=10.5;
//a=b+10.5;//这个代码此时就是错误的,会发生整形提升,除非进行强制类型转换
a+=b;//这种操作,会自动的帮我们进行强制类型转换,会自动转化成int类型
System.out.println(a);//最终打印的结果还是int类型

1)在java中一个unicode占2个字节(byte). 一个字节等于8比特位(bit). 所以每个Unicode码占用 16 个比特位 

2)所有关系运算符的结果，要么是true，要么是false，不可以写成if(9<a<10)

逻辑运算符: 

一:布尔表达式1&&布尔表达式2

 int a=10;
 int b=10;
 System.out.println(a&&b);

注意:

 int a=10;
 System.out.println(a<=10&&10/0<10);//后端部分会出现空指针异常
 System.out.println(a>90&&10/0==0);

1)两个表达式必须都是布尔表达式

2)如果第一个表达式为假，那么不会执行第二个表达式，也叫作短路与

二:布尔表达式1||布尔表达式2，如果说布尔表达式1为真，那么不会判断执行布尔表达式2

三:!取非，必须作用于布尔表达式上面:

int a=10;
System.out.println(!a);//必须是布尔表达式

注意:如果我们这么写:

 int a=100;
 int b=190;
 System.out.println(a&b);
 System.out.println(a>190&10/0==0);
 System.out.println(b>100|b/0==0);

1)如果说&和I两边是布尔表达式，那么直接按照逻辑运算符来进行工作，但是不会造成短路的问题

2)如果说&和l两边都是数字，那么直接按照按位与，按位或，按位取反

6.int与String之间的相互转换

//1 int转换成String
        int a=10;
        String str1=a+"";
        System.out.println(str1);
        String str2=String.valueOf(a);
        System.out.println(str2);
 //2 String 转换成int
 String str="100";
 int num=Integer.parseInt(str);
 System.out.println(num);

 7.一些算数运算符的常见问题:JAVA对数据操作的基本单位不是字节，而是二进制位

//1 a++和++a的区别
        int a=10;
        int b=a++;//先进行赋值,在进行++  b=a  a=a+1
        int c=++a;//先进行++,在进行赋值  a=a+1 c=a
        System.out.println(b);//10
        System.out.println(c);//12
//2 注意关系运算符的返回值都是boolean类型
//3 位运算符
位运算表示按二进制位来进行运算,计算机中都是使用二进制位来进行表示数据的(0,1构成的序列),位运算就是再按照二进制位来进行每一位的运算;
1)按位与&
如果两个二进制位都是1则是1,否则结果为0
2)按位或|
如果两个二进制位都是0则位0,否则结果是1
3)按位取反~
是0改成1,是1改成0
4)按位异或^
不一样的进行或,不一样的都是0
如果两个数字的二进制位相同,那么结果就是0,不相同结果就是1
//4移位运算
1)<<左移
最左侧不要了,右侧补0
2)>>右移
最右侧不要了,左侧正数补0,负数补1
//3条件运算符
表达式1?表达式2:表达式3,当表达式1的值是true的时候,整个表达式的值是表达式2;当表达式1的值是false的时候，整个表达式的值是表达式3;
是闰年的条件:被4整除,但是不可以被100整除;或者可以被400整除
year%4==0&&year%100!=0||year%400==0

如果不写()，else语句会和最近的那个if语句进行匹配

switch括号中不可以写的类型，里面只能写一个变量，break不能省略

“java中switch()括号中不能放“long”,“float”,“double”,“boolean”类型的数据，可以使用“byte”，“short”，“char”，“int”，“枚举类型”，“String”类型的，“Short"，”Integer"，“Character"数据，从JDK1.5开始枚举类型也是可以作为switch的参数

   String str = "abcdefg";
        switch (str) {
            case "abcdefg":
                System.out.println("生命在于运动");
                break;
            case "abcd":
                System.out.println("生命在于吃饭");
                break;
            case "bbbb":
                System.out.println("生命在于学习");
                break;
            default:
                System.out.println("默认值");
                break;
        }

标识符:只能由数字+字母+下划线(变量名)

1)不能以数字开头

2)变量名不可以是关键字，比如说if else不能用作变量名，但是可以用main作为变量名字

3)可以以美元开头

4)name:j:这是不行的

5)大小写没有什么关系

  System.out.println(5/2);//计算出来的结果,只会进行存储整数
  System.out.println(5.0/2);//会保存小数
  System.out.println(5/2.0);
  System.out.println(5.0/2.0);//只要运算位上面有一个小数,那么结果就会保存位小数
  System.out.println((float)5/2);//分子相当于变成了5.0
  System.out.println(5/(float)2);//分母相当于2.0
  System.out.println((float)(5/2));//算出的结果是2,墙砖的结果是2.0

System.out.println(10%3);//1
System.out.println(-10%3);//-1
System.out.println(10%-3);//1
System.out.println(-10%-3);//-1

1)现在比如说:0000 1011<<1变成:0001 0110---->11*2^1

2)现在比如说:0000 1011<<2变成:0010 1100------>11*2^2

3)现在比如说:0000 1011>>1变成:0000 0101

4)0000 1011>>2--->0000 0010

5)如果是负数，右移补符号位:1111 1111>>1--->11111111

无符号右移:无论是否是符号位，右移统统补成0:

11111111>>>1--->0111 1111

int c=布尔表达式？值1:值2--->如果布尔表达式是真，那么c=值1

注意:

1)表达式1和表达式2的结果必须是同类型的，除非可以发生隐式类型转换

2)表达式不可以单独存在，其产生的结果必须能够使用

运算符的优先级:+的优先级要比>>的优先级高，对于位运算的操作符，要加上括号

if(里面是布尔表达式)

 short a=1;
      switch (a){
          case 1:
              System.out.println("我是1");
              break;
          case 2:
              System.out.println("我是2");
              break;
          default:
              System.out.println("啥也不是");
              break;
      }
//不能有两个case的值是一样的

1)多个case后面的常量值是不可以进行重复的

2)break不能遗漏，况且case里面不能是表达式

去面试的时候尽量穿一些有关于编程的衣服