Java基础

一、注释、标识符、关键字

数据类型、类型转换、变量常量，运算符，包机制、JavaDoc

1.注释

注释：代码量少还能看懂自己写的，但当项目结构一复杂起来，就需要用到注释了。

注释并不会被执行

写注释是一个非常好的习惯

平时写代码一定要注意规范

Java中的注释有三种

单行注释 //
多行注释 /* */
文档注释 /** @Author 有识别功能 */

当建一个新项目时，先选择空项目，
再新建要选择模块，因为我们已经是一个新项目/工程，不能再建一个项目对吧。
然后寻找项目结构，选择project，将项目SDK设置为1.8，项目语言等级都设置为1.8，点击应用，点击确定。

1.1 代码

psvm,sout，这些代码了然于胸哦

注意中英文啊，"Hello,World!",英文双引号啥的直接打出来的

不配置环境，可能运行符号都不给你打出来。

System.out.println() 也可以输出变量名

1.2 快捷键

复制上一行快捷键Ctrl+d

Ctrl+Y 快速删除当前行

2.标识符

Java的所有组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

所有的标识符都应该以字母、美元符$、或者下划线_开始。

首字符后，可以是字母、美元符$、下划线_或者数字的组合。

不能使用关键字作为变量名和方法名。

标识符是大小写敏感的。

二、数据类型

Java 强类型语言，要求十分严格，会让大家养成一个规范的习惯

即要变量的使用严格符合规定，所有变量必须先定义后使用。

1.各数据类型

回到生活中来看，平时生活中，一般会用到哪些东西啊，思考：数字，文字(字符)，数字可分为整数，小数

Java，数值类型和boolean类型，(Boolean类型，即生活中的是否对错)

数值类型也分为三个，整数类型，浮点类型，字符类型

整数类型：byte(1字节-128-127),short(2字节-32768-32767),int(4字节，+-21亿),long(8字节)

（这四个都可以代表整数，但是我们知道，计算机是有自己的固定大小，一个硬盘u盘，类似的，四个不一样的东西表示不一样的范围。）

浮点类型：float(4字节)，double(8字节)

字符类型：char(2字节)

布尔类型：占1位，其值只有True和False两个

PS：float和double都是小数，float后面要加F做区分；int和long，long后面要加L做区分。

字符是一个字了，a可以，秦疆就不可以。要加单引号。

PS：字符串String不是关键字，是一个类。

PS：Java 里 int 对应的integer 是一个类，其代码里表明了最大值是多少，最小值是多少。

Ctrl+鼠标点击类名，进入到类的代码？还是类的注释。

引用类型，reference type 基本类型 primitive type

Java除了基本类型，都是引用数据类型，比如Integer,byte,String都是一个个类，都是引用数据类型，接口和数组是面向对象的时候学。

1.1 字节

位bit：计算机内部数据储存的最小单位，11001100是一个八位二进制数

字节byte：是计算机中数据处理的基本单位，习惯上用大写B表示

1B=8bit，1字节等于8位

字符，指计算机中使用的字母、数字、字和符号

ps，32位只能装32位cpu，64位既可以装32位操作系统的cpu，又可以装64位操作系统的cpu。在内存中的寻址能力，与32位还是64位直接挂钩，64位最多可以支持128G的内存，32位最多可以支持4GB的内存，

2.数据类型扩展及常见的问题

这也可能是面试笔试中问道的，因此啊，必须注意听，掌握

println输出打印换行，print输出打印不换行

==在对比变量是对比值. 对比引用类型是对比地址值. new必定是创建一个新的地址第一个不相同. string是存在常量池中,两个标识符指向的同一个地址所以第二个相同

第一个是堆内存地址不一样，第二个是同一个常量池

==：如果比较的对象是基本数据类型，则比较的是数值是否一致；如果比较的是引用数据类型，则比较的是对象的地址值是否一致。

引用类型比较地址值，基本类型比较值是否一样

new是开辟了新的内存空间,不new的是指向同一个内存空间

上面new了两个新对象，分别存在堆里，地址是不一样的。下面是两个引用都指向了常量池里的值，地址是一样的

两个变量都是使用 new 来实例化，所以是在内存中开辟了两块内存, 也就是指向的内存地址不相同

《程序是怎么跑起来的》

这章很重要，如何理解好呢？首先在笔记总结一下，其次自己再敲一下代码。

2.1整数拓展

二进制0b，逢2进1；八进制0，逢8进1；十进制，逢10进1；十六进制0x，逢16进1；

2.2浮点数拓展

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

float 有限离散存在舍入误差

例子，float0.1和double1.0/10 输出结果一样，但是在计算机眼里是不相等的，是False。

float一个大数加1，正常来说应该是不一样的，但是在计算机是和原先大数的输出结果一样，是True

所以再面试时，银行或可能会问，能不能使用float这个基本数据类型，来表示钱呢，

答案是显然的，不可以，需要使用BigDecimal，大数类型，数学工具类，来表示钱

2.3字符拓展

所有的字符本质是数字

例子，通过强制类型转换，打印输出一个字符。如，char a1 = 'a';System.out.println((int)a1);

所有的字符本质是数字，有一个Unicode表，在表里，97 = a（表是2 16次幂 66536）/u0000 /uffff

所以这也可能会，表示字符时，可能会通过一些Unicode编码通过转义来进行表示字符

类似的，转移字符常用的还有制表符\t 换行符\n

反斜杠\

2.4布尔型拓展

 if (flag==true){}
 if(flag){}

Java里中括号，比如输入if(){}貌似没有自动补全

2.5 引用类型比较地址，基本类型比较值

new两个新对象，分别存在堆里，地址是不一样的；而string HelloWorld 两个引用都指向了常量池里的值，地址是一样的。

换种说法，两个变量通过new实例化，是在内存中开辟了两块内存，开辟了新的内存空间，不new的指向的是同一个内存空间，所以一个地址一样，一个地址不一样

例子，第一个输出结果False，第二个输出结果True

 String a = new String("Hello,World");
 String b = new String("Hello,World");
 System.out.println(a==b);
 String c = "Hello,World";
 String d = "Hello,World";
 System.out.println(c==d);

三、类型转换

Java是强类型语言，所以在进行一些运算时，需要进行类型转换，，

如，整型跟一些常量、字符串等，是可以混合运算的，通过类型转换。

具体：byte,short,char--int--long(64)--float(32)--double 从低到高---为什么long在float后面，是因为小数的优先级一定大于整数

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

byte，有一个对应的类Byte，其最大值是127

 public class Demo05 {
     public static void main(String[] args) {
         int i = 128;
         double b = i;
         System.out.println(i);
         System.out.println(b);
         //将i的值赋给b，但是如果不进行强制类型转换，报错，因为需要一个byte类型，确赋给了int类型
         //输出结果是128 -128 显然，byte对应的Byte类，最大值范围是-128 127，内存溢出了
         //所以转换的时候，尽量避免内存溢出的情况
         //强制类型转换,(类型)变量名  高--->低
         //自动类型转换,什么都不用写  低--->高
 
         /*
         注意点：
         1.不能对布尔型进行转换
         2.不能把对象类型转换为不相干的类型（变量也叫对象），，比如，，可以把人转换为一头猪？不行，，但是，可以把一个男人变成女人啊。。
         3.在把高容量转化为低容量时，强制转换，反之，不用动，自动转换了。
         4.转换时，可能存在内存溢出，或者精度问题
          */
 
         System.out.println("=====================");
         System.out.println((int)23.7);      //float
         System.out.println((int)-45.89f);    //double
 
         System.out.println("=====================");
         char a = 'a';
         int d = a + 1;
         System.out.println(d);
         System.out.println((char)d);
     }
 }

 public class Demo06 {
     public static void main(String[] args) {
         //操作比较大的时候，注意溢出问题
         //JDK7新特性，数字之间可以用下划线分割，比如下面的10亿之间可以用下划线分割，这样就清楚了。
         int money = 10_0000_0000;
         int years = 20;
         int total = money * years;  //-1474836480 计算时溢出 , 那用long来接收行不行呢？试一下
         long total2 = money*years;  //结果还是-1474836480，原因，默认是int，转换之前已经存在问题了。如何解决？
 
         long total3 = money*((long)years);  //结果是20000000000了，正常。  先把一个数转换为long
         System.out.println(total3);
 
         //还要注意下就是，l 和  L都可以代表long  但有时程序里“l”与1比较接近，因此最好用大写L 10_0000_0000L;
     }
 }

四、变量

变量，生活会中方程、函数，y=x；顾名思义，可以变化的量

通过变量，来操作内存中的数据

变量，可能指代内存中的一个空间，空间里面放什么东西是不确定的，

相当于空间位置是确定的，是定死的，但是内容是什么是不确定的

来个生活中的比喻吧，就好比我们家里有个柜子，柜子有上下三个格子，每个格子的位置和空间是固定的，但是放什么东西不确定，我们给每个格子来个定义，比如依次放鞋子，衣服，袜子，而鞋子当然也可以有不同的名字，比如阿迪鞋子，耐克鞋子等等

即：变量必须有个空间，比如整型变量，而不同的整型变量如何区分？要加变量名。

即：数据类型和变量名确定了，具体放什么值就是自然的了。

Java是一种强类型语言，每个变量都必须声名其类型；

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

java变量数据类型变量名 = 值，可以一行多个值，但不建议

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

引用类型，类，接口，数组，后两者面向对象时候学，类包括Integer,String,Byte等

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

不能以#开头，字母、$、_。

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

1.作用域

1.1类变量

写在类里面，同实例变量的区别是加一个关键字static。ps：定义好类变量，可以直接在方法里输出。类变量从属于类，随着类一起出现，一起消失。
之后讲到内存分析gvm时，再重点去讲解static。在目前的学习阶段，都先把方法、类变量都加个static，我们好去调用它，不用去new了。(此时还没学new，这个关键词在对象的时候学习。)

1.2实例变量

写在类中（类里方法外）：从属于对象，若不知道什么是对象，在这里理解为它从属于类demo08。举例如下，写好String name;之后再用，可以通过创建的类对象，进行实例对象的调用，不用初始化，但具体用的时候，不像是在方法中的变量声明和初始化后可以直接用，需要调用。
在实例变量中，如果不进行初始化会变成这个类型的默认值。所有的数值类型的默认值是0(整数)或0.0(小数)，字符类型的默认值是16位0，即u0000 ，布尔值，默认值是False；除了基本类型的默认值都是null
```
 String name;
 int age;
```

ps：实例变量的使用：（快捷键：Alt + Enter 跳出提示再按一下回车就可以了--快速输入--IDEA万能建）

要新建类的对象，再通过对象名去点他，引用。而且还要写set get方法

new Demo08() 相当于把这一个类，拿到了，Alt + Enter 跳出提示再按一下回车，快捷输入；它会通过这个类返回一个Demo08的实例对象

此时的变量类型为Demo08，变量名为demo08（可以自己改），变量类型也可以是我们自己定义的，即自定义类型，类，也是引用数据类型。

变量名字有一个值， = new Demo08 （new了一个Demo08），相当于把它自己给拿到了。这个变量就是这个Demo08他自己.

然后我们通过这个demo08(变量名)，就可以用它的东西了。

输出格式为demo08.age(会有提示).sout 会变成System.out.println(demo08.age);

从属于类，从属于对象，就得这么使用，比较麻烦。

自然，有没有像是局部变量，这样定义好就可以直接输出的简便方式呢？答案是自然有的。类变量

1.3局部变量

局部变量，写在方法中，它的生命周期从 { 括号开始，到 } 结束；且在使用前，必须声明和初始化值；比如在main方法里定义并初始化一个变量i，但在其它方法里这个i是无法打印输出的。类似的，有个代码块static{}，在代码块里定义，变量也是在{}范围内有效的，但加了static关键字，作用域就非常高的

ps：类里面除了一些方法还可以定义一些属性，在这个课时里，属性可以简单理解为变量。

2.常量

常量，constant，初始化后不能再改变值，initialize，不会变动的值。

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

关键词final，定义final 常量名 = 常量值如final double PI = 3.14

常量名一般使用大写字符

变量类型前面的东西都是修饰符，不存在先后顺序，比如final static

使用一些常量可以提高某些代码的可读性，比如把一些固定的东西，游戏的宽跟高等，设置死了。开发一些东西，有些始终不会变的，就定义成静态的常量

在类里使用类变量(静态变量)，无论在哪里都可以直接调用，哎，就比较方便。(定义常量进行引用)比如定义一个常量，给它固定值，也比在各个方法里一遍遍写好很多。比如PI值3.14,万一在哪个程序里写错了，就很麻烦，程序可能崩了。程序千万不能有丝毫差错。

3.变量的命名规范

所有变量、方法、类名：见名知意
类成员变量(除了常量)：（类变量实例变量局部变量）首字母小写和驼峰原则：monthSalary 除了第一个单词意外，后面的单词，首字母大写 ---比如lastname lastName
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：Man GoodMan
方法名：首字母小写和驼峰原则: run(), runRun()

包名统一小写，单数形式

五、运算符

计算机，计算，加减乘除，需要一个运算符进行操作

算术运算符：+-*/ 取余运算==模运算++ --
赋值运算符：= int a =b;
关系运算符：> ,< , >= ,<= ,!=, == ,instanceof
逻辑运算符：&&--与and ，||--或or ，！--非，取反；
位运算符：&与， |或 , ^疑惑 ,~取反, >>右移, <<左移 ,>>>无符号右移
条件运算符：表达式1？表达式2：表达式3
扩展赋值运算符：

前四类运算符，算术赋值关系逻辑必须掌握，后三类，了解会用即可。位运算符，计算机位操作的；条件运算符，拓展赋值运算符是为了偷懒创造的，哈哈。

 <<左移    *2  M << n  = M * 2n
 >>右移    /2 最高位是1补1，最高位是0补0  M >> n  = M / 2^n
 <<<右移   且把最高位补0

包机制，相当于文件夹。package 包名；这个不要删除，删掉会报错。

按shift键，选中第一个和最后一个就行了，可以一次全选文件。在打开的java.class文件右击，可以选择关闭全部

10/20=0.5 但是整形数只有整数部分，因此输出结果是0；

解决方案，强制类型转换一下，将运算的一方强制转换为double型即可

 System.out.println(a/(double)b);

如上，把计算其中的一方强制类型转换为double，在计算之前把精读问题解决掉。

多个操作数中，有一个操作数最高为Long,那么运算结果类型也为Long，如果是byte，int，short，那么结果都为Int。如果最高有float，结果是float类型；如果最高位double，结果是double类型

2020.1版本可以把鼠标指针移动到println上查看输出后的数据类型。

类似+ - * /需要两个操作数，二目(二元)运算符，而类似++ -- ，只需要一个操作数就够了，即单目（一元）运算符

 //++a就是先自增后用，a++就是先用后自增

1.运算符的优先级()

多使用()，一元运算符，加减乘除，。。

表达式里有就优先使用()，为了更方便使用，也便于阅读理解。

六、包机制

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

包语句的语法格式为：

 package pkg1[.pkg2[.pkg3]]

包的本质就是文件夹。

想到Windows里一个文件夹里不能有两个重名文件，因此，两个同名文件要想同时存在，必须处于不同的文件夹中。

一般利用公司域名倒置作为包名

com.yin.ahut

重点是防止命名空间重复的一个问题。

www.baidu.com com.baidu.www baike

为了能够使用某一个包的成员，我们需要在java程序中明确导入该包。使用import语句可以完成该功能

 import package1[.package2 ...].(classname|*)

注意导入语句要放在package下面。也要注意导入的包的类名，不要和本包里的类名相同。

注解

 /**
  *@author yss
  *@version 1.0
  *@since 1.8
  *@param 参数
  *@return 返回值
  *@throw 抛出异常
  */
 
 //通过命令行生成Java文档  javadoc -encoding UTF-8 -charset UTF-8 文件名.java
 Javadoc 参数 java文件

总结

从Java基础语法这里，

认识了什么是注释，标识符，关键字，基本数据类型与类型转换

能定义一些基本的变量，知道什么是常量，运算符

知道怎么把项目搭建的规规范范的

知道包机制，知道文档怎么生成，可以让写的代码，变成人家都能读懂的东西。

posted @ 2021-04-05 15:15 蓝冰snooze 阅读(86) 评论(0) 收藏举报

刷新页面返回顶部

yss_blue