Java基础
在开始学习Java基础之前,我们先来学习一下IDEA
打开IDEA,新建一个项目(New Project),选择空项目(Empty Project),填写项目名(Project name)比如我的JavaSE,填写路径(Project localtion)比如我的D:/代码/JavaSE,最后选择结束Finish;这样我们的空项目就建好了;加载好后如果提示就选择This Windows
在IDEA左上角选择文件(File),选择新(New),选择新建模块(New Module),选择Java,保证模块的SDK与我们安装的版本一致,选择下一步(Next),模块名(Module name)比如我的基础语法,选择根路径(Content root)比如我的D:\代码\JavaSE\基础语法,最后选择结束(Finish)l;这样新的模块就建好了
最后来配置Java的环境,这一步不做的话Java在IDEA上是无法运行的。在左上角选择文件(File),选择项目结构(project Structure),再选择项目(project),名字(Name
)填项目名即可,比如我的JavaSE,SDK选择我们对应的版本,语言等级(Language level)选择8,因为我们装的是8,编译器输出的内容保持路径(Compiler output)比如我的D:\代码\JavaSE\out,然后应用(Apply),最后ok
这样我们就可以新建class了,我一般习惯在src下面新建
如果代码class文件多的话可以新建一个包(也就是文件夹来存放代码),在src这里右键,选择new,选择package,输入名字,然后就能把包拖进去;不过需要注意,每个java文件开头都会多一句(package 包名;)这一句不能删,删了就会报错,这句是用来声明,这个java文件是在这个包里面
注释、标识符、关键字
注释
平时我们编写代码,在代码量较少的时候,我们还可以看懂自己写的,但是当项目结构一旦复杂起来,我们就需要用到注释
注释并不会被执行,是给我们写代码的人看的
- 重点书写注释是一个非常好的习惯,利于自己也利于别人!
这里我在这里吐槽一下:我一个学了一年多Python的同事,为了便利 工作写了一个自动化脚本,跟我说运行起来老是报错,检查过了很多遍,想让我帮忙看一眼。我觉得也没有多大事,就让他发来,下载后我打开一看,整篇下来一个注释都没有。。。我直接傻眼。想着毕竟话都放出去了,而且代码量不是很庞大。硬着头皮给他看完了,我还给他加上了注释!在此我奉劝各位仁兄,为了我们的头发也为了自己的头发,一定要好好写注释!一定要好好写注释!一定要好好写注释!
Java中的注释有三种
- 单行注释(// 注释)
public class Hello{
public static void main(String[] ages){
// 输出一个Hello,World!
System.out.println("Hello,World!")
}
}
- 多行注释(/星号开头星号/结尾,中间都为注释)
public class Hello{
public static void main(String[] ages){
/*
输出一个Hello,World!
输出一个Hello,World!
输出一个Hello,World!
*/
System.out.println("Hello,World!")
}
}
- 文档注释
这个后面JavaDoc再讲,一般很少写文档注释
关键字
在学习标识符之前我们先了解一下关键字
在我们使用IDEA写java程序的时候那些高亮的单词就是关键字,比如:public class等
常用的关键字有下面这些
以后就要记住取名字就不能使用关键字里面有的了,比如你创建一个类
public class class{
......
}
这样是会报错的!
标识符
- *Java 所有的组成部分都需要名字。比如:类名、变量以及方法名都被称为标识符
类名:我们写Hello程序的时候,其中和文件名一样的那个就是类名;是标识符
变量:String a = “小迪”; 我们定义一个变量就是这样,其中a是变量名;是标识符
方法:public static void main(String[] args) {}其中main就是我们的方法名;是标识符
如果上面这些变量这些看的不是很懂的话没关系,我这里只是告诉你上面是标识符,其他的后面会讲
标识符的注意点
- 所有的标识符都应该以字母(A-Z或a-z),美元符($)、或者下划线(_)开始
- 首字符之后可以是字母(A-Z或a-z),美元符($)、或者下划线(_)或数字的任何字符组合
- 不能使用关键字作为标识符
- 标识符是大小写敏感的(意思就是区分大小写)
- 合法标识符举例:age、$xiaodi、_China、__2_value
- 非法举例:1value、%salary、^open
- 可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音(不过我不精通英语有时候也会用)
什么是字节
位(bit):是计算机 内部数据 储存的最小单位,11001100是一个八位二进制数
字节(byte):是计算简中 数据处理 的基本单位,习惯用大写的B来表示
1B (byte,字节)= 8bit (位)
字符:是指计算机中使用的字母、数字、字和符号
1bit表示1位
1Byte表示一个字节 1B=8b
1024B=1kb
1024kb=1M
1024M=1G
数据类型
强类型语言
- Java是一种强类型语言;要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用;也就是说一旦定义了一个变量,指定了某个数据类型,如果你不经过转换的话他就永远是这个类型了;安全性高相对的弊端速度会变慢;
如下代码:
public class Demo01{
public static void main(String[] args){
String name=1;
int num="XiaoDi";
}
}
这是错误示范:
我们定义name为字符串类型的变量却把数字类型的值赋值给它
定义num为数值类型却把字符串类型的值赋值给它
以上这种书写是错误的,我们必须严格符合规定的书写,将name的值改为字符串类型、num的值改为数字类型;如下代码:
public class Demo01{
public static void main(String[] args){
String name="XiaoDi";
int num=1;
}
}
弱类型语言
与强类型语言相反,这里就不做演示了!
Java的数据类型分为两大类
基本数据类型(primitive type)
数值类型
整数类型
byte占一个字节范围:-128-127 超过字节范围就会报错
short占两个字节范围:-32768-32767
int占4个字节范围:-2147483648-2147483647 一般这个就够用了
long占8个字节范围:-9223372036854775808-9223372036854775807
浮点类型
float占4个字节
double占8个字节 常用
字符类型
char占两个字节
boolean类型
占1位其值只有true和false两个
public class Demo02{
public static void main(String[] args){
//八大基本数据类型
//整数
int num1 = 10; //最常用
byte num2 = 20;
short num3 = 30;
long num4 = 30L; //long类型要在数字后面加个L
//小数:浮点数
float num5 = 50.1F; //float类型要在数字后面加个F
double num6 = 3.1415926535;
//字符
char name = 'A'; //只能写一个字符,超过就报错
//字符串,String不是关键字,是类
//String namea = "小迪";
//布尔值:是,非 1,0
boolean flag = true;
//boolean flag = false;
}
}
引用数据类型 (reference type)
类、接口、数组;后面学
数据类型扩展及面试题讲解
整数、浮点类型扩展
public class Demo03{
public static void main(String[] args){
//整数扩展: 进制 二进制用0b表示 十进制 八进制0表示 十六进制0x表示
int i = 10;
int i2 = 010; //八进制0表示
int i3 = 0x10; //十六进制0x 0~9 A~F F为16
//浮点数扩展
float f = 0.1F; //0.1
double d = 1.0/10; //0.1
System.out.println(f==d); //输出结果false
//明明两个是相等的应该输出true才对啊
//再来看一下下面这个更诡异的
float d1 = 231313123123123113F;
float d2 = d1 + 1;
System.out.println(d1==d2); //输出结果true
//两个值完全是不相等的,但是判断时却返回true
}
}
那么为什么会出现上面这种情况呢?首先,我们这个浮点数表现的字长是有限的,一般会存在一个舍入误差的东西,因为有很多数字它没办法精确表示,所以它的结果只能是个大约数。(接近但不等于)
所以总结出一句话:
- 最好完全避免使用浮点数进行比较
- 最好完全避免使用浮点数进行比较
- 最好完全避免使用浮点数进行比较
那么有人就会问:我们如果一定需要用到浮点数进行比较怎么办?比如银行的业务怎么表示?钱
我们后面会学到一个类:BigDecimal 数学工具类
字符类型扩展
public class Demo04{
public static void main(String[] args){
//字符型扩展
char c1 = 'a';
char c2 = '中';
System.out.println((int)c1); //强制转换 输出结果为97
System.out.println((int)c2); //强制转换 输出结果为20013
}
}
以上这种情况,我们是使用了类型转换,将字符转换成了数字,那为什么a是97,中是20013呢?
记住下面这句话:
- *所有的字符本质还是数字
char类型会涉及到编码问题:Unicode编码 可以处理各种语言的文字,占2字节
我们也可以像下面这样直接给变量c3赋值Unicode编码,再进行输出 (其中\是转义不懂没关系下面会讲)
char c3 = '\u0061';
System.out.println(c3); //输出结果为:a
//这个是一些底层的原理,了解一下就ok,万一以后大家面试被问到了就懂了!
转义字符
- \t:制表符:转义成tab键
- \n:换行:相当于回车键
如图下:
这里我给大家留一个悬念
String sa = new String(original:"hello world");
String sb = new String(original:"hello world");
System.out.println(sa==sb); //输出结果为false
为什么两个值是一样的,却返回false
等后面学到对象的时候,再给大家从内存级别分析一下为什么
布尔值扩展
if语句我们还没有学我们也留一个悬念在这!
public class Demo05{
public static void main(String[] args){
boolean flag = true;
//我们一般会通过布尔值做一些判断;如下
if (flag==true){} //新手
//有的代码它不会把==true写出来它会像下面这种写法
if (flag){} //老手
//只是写法不一样但是意思和作用是一样的
}
}
这两种写法可以看出写代码的人是新手还是老手;
java中有一个概念叫做:Less is More!(少即是多);我的理解是: 代码要精简易读
类型转换
由于Java是强类型语言,所以要进行有些运算的时候,需要用到类型转换。
底--------------------------------------------->高
byte,short,char -> int -> long -> float -> double
//有人会问float才4个字节32位,为什么会比long8个字节64位高
//整型的优先级比浮点型低是因为,浮点类型的数据如果转换成整型就会损失精度,就是小数点后面的数会被省略
运算中,不同类型的数据,必须先转化为同一类型,然后进行运算。
强制类型转换
高转低的时候使用的转换方式
强制类型转换格式:(类型)变量名
public class Demo06{
public static void main(String[] args){
//int i = 128;
//byte b = i;
//上面这种写法是错误会报错的,因为i是int类型,b是byte类型,而且int的类型的优先级比byte的优先级高,是不能进行自动类型转换的;我们需要把i进行强制转换成byte类型才能进行赋值操作。如下:
int i = 128;
byte b = (byte)i;
System.out.println(i); //输出结果为:128
System.out.println(b); //输出结果为:-128
}
}
i输出结果为128没问题,那么为什么b的输出结果会等于-128呢?
我们在IDEA输入Byte按住Crte双击这个会打开这个函数的帮助文档;在帮助文档可以看到byte最大值是127,然而我们却给它b赋值了128,就导致了 内存溢出的问题了;内存溢出的话你就不知道这个值会变成什么了。
- 所以我们在转换的过程中尽量避免这种内存溢出的情况
自动类型转换
底转高的时候使用的转换方式
自动类型转换是可以直接转的
public class Demo07{
public static void main(String[] args){
int i = 128;
double b = i;
}
}
注意点总结:
- 不能对布尔值进行转换
- 不相干的类型不能进行转换
- 高优先级类型转换为低优先级类型需要使用强制转换;反之不需要进行多余操作
- 转换的时候可能存在内存溢出,或者精度问题
public class Demo08{
public static void main(String[] args){
//精度问题,存在于浮点型
System.out.println((int)23.7); //输出结果为:23
System.out.println((int)-45.89F); //输出结果为:-45
}
}
类型转换例子:
public class Demo09{
public static void main(String[] args){
char c = 'a'; //这里注意一下,字符型要使用单引号,字符串使用双引号;
int d = c+1;
System.out.println(d); //输出结果为:98
System.out.println((char)d); //输出结果为:b
}
}
常见问题
public class Demo10{
public static void main(String[] args){
//操作较大的数的时候,注意溢出问题;顺便介绍一下JDK7的新特性:数字之间可以使用下划线分割,且不被输出
int money = 10_0000_0000; //大家一年赚的钱
//System.out.println(money); //输出结果为:1000000000
int years = 20; //大家比较勤奋干了20年
int total = money*years; //全部的钱
//System.out.println(total);
//输出结果为:-1474836480;怎么还倒赔了?噢原来是 内存溢出;那么我用long试试
long tota2 = money*years;
//System.out.println(tota2);
//输出结果还是:-1474836480;难道真的亏了?不不不,是因为money和years是int类型,money*years先计算好之后才把它转换为long类型,转换之前已经存在问题了,这个时候我们就不能这样去做
//正确操作
long tota3 = money*((long)years);
System.out.println(tota3); //输出结果:20000000000
//这才是大家总共赚的钱,我写的那么辛苦多多少少也拿点分我花哈哈
}
}
好习惯
long num4 = 30L; //long类型要在数字后面加个L,虽然小写的l也可以,但是容易看成1,最好使用大写的L
float num5 = 50.1F; //float也是一样最好使用大写
//像上面这种代码中赋值操作=两边最好也是加一个空格,这样代码看起来会比较整洁,养成好习惯从小迪做起
变量、常量、作用域
变量
- 变量是什么:就是可以变化的量!
- Java是一种强类型语言,每个变量都必须声明其类型。
- Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和 *作用域
type varName [=value] [{,varName[=value]}];
数据类型 变量名 = 值;可以使用逗号隔开来声明多个同类型变量,但是我是不建议在一行里定义多个值的,因为这样看起来会很乱。
public class Demo11{
public static void main(String[] args){
//声明变量
//格式:数据类型 变量名 = 值
String name = "XiaoDi";
char x = 'X';
int num = 123;
}
}
注意事项
- 每个变量都有类型,类型可以是 基本类型,也可以是 引用类型
- 变量名必须是合法的 标识符
- 变量声明是一条完整的语句,因此每一个声明都必须以 分号结束
变量作用域
新认知
public class Demo12{
//Demo12{},这是我们定义的一个类
//类里面可以定义方法、属性(大家可以先理解为变量)
public static void main(String[] args){
//main(String[] args){},这是我们的一个main方法
}
//除了main方法我们还可以定义其他方法
public void add(){
}
}
有了上面的这些新认知我们来看一下 局部变量:
局部变量是在我们方法和语句块里面的;(语句块还没学先不管)
public class Demo12{
public static void main(String[] args){
//局部变量:必须声明和初始化值
// int i;
// System.out.println(i); 你会发现这样是输出不了的,因为他没有初始化值
int i = 10;
System.out.println(i); //输出结果:10 且它的作用域只限于main的方法里面
}
public void add(){
// System.out.println(i); //我在这里输出main方法里面的i是不行的,会报错
}
}
我们再来看一下 实例变量:
实例变量在我们的方法外面,类的里面;而且你需要通过这个类才能使用
public class Demo12{
//实例变量:从属于对象;(我们还没有学对象,你只要知道我们需要通过Demo12这个类才能去使用它)
//需要声明,可无须初始化值
String name;
int agr;
public static void main(String[] args){
//实例变量的使用:这一段大家看不懂没关系,先了解一下,看一下就行
//变量类型 变量名字 = new Demo12();
Demo12 demo12 = new Demo12();
System.out.println(demo12.age); //输出结果为:0
System.out.println(demo12.name); //输出结果为:null
}
public void add(){
}
}
注意:
实例变量如果没初始化值,所有的数值类型的默认初始化值都是:0或0.0(0是整数类型;0.0是浮点数);字符类型的话是 u0000,但是它也会输出0;布尔值默认是false;除了基本类型其他都为null。
类变量:
也是在方法外面,类里面;只不过他再调用的时候不需要像实例变量那么麻烦。
public class Demo12{
//类变量:static 后面讲到jvm会给大家分析
static double salary = 2500;
public static void main(String[] args){
System.out.println(salary); //输出结果为2500.0;是可以直接输出的
}
public void add(){
}
}
后面我们在学习的过程中,遇到需要在类里面方法外面定义的变量,我们就使用类变量,这样就不用去new了
有一些大家听不懂的,不用去纠结,我们后面都会学到的;重点记一下关键字:static
常量
常量(Constant):初始化后不能在改变值!不会变动的值。
常量可以理解为一种特殊的变量,它的值被设定后,在程序运行的过程中不允许被改变。
- 语法:final 常量名 = 值 或者 final 数据类型 常量名 = 值;
- 常量名一般使用大写字符
public class Demo13{
//类变量的定义方法 +常量
static final double PI = 3.14;
//修饰符不存在先后顺序,static和final谁在前面都一样
public static void main(String[] args){
System.out.println(PI);
}
}
一般运用在:假如你要写一个游戏,要设置宽和高(不需要变动的值),我们把宽和高设置成赋值给常量即可;
变量的命名规范
所有变量、方法、类名: 见名知意
类成员变量(类里面方法外面的变量):首字母小写和驼峰原则:monthSalary
局部变量:首字母小写和驼峰原则
方法名:首字母小写和驼峰原则:run(),runRun()
常量:大写字母(如果多个单词就以下划线分开):MAX_VALUE
类名:首字母大写和驼峰原则:Man,GoodMan
运算符
Java语言支持如下运算符
算数运算符:+,-,,/,%,++,–(加、减、乘、除、取余、后面两个等一下讲)
赋值运算符:=(java中=是赋值才是等于)
关系运算符*:>,
位运算符:&,|,^,~,>>,<
条件运算符:?,:
扩展赋值运算符:+=,-=,*=,/=
- 前面字体加粗的4种运算符是一定要掌握的,位运算符了解一下就行,后面这两个是用来偷懒用的,会就行
算数运算符
演示 加减乘除:
public class Demo14{
public static void main(String[] args){
//+ - * / 二元运算符:就是需要两个操作数的
int a = 10;
int b = 20;
int c = 30;
int d = 40;
System.out.println(a+b); //结果:30
System.out.println(a-b); //结果:-10
System.out.println(a*b); //结果:200
System.out.println(a/b); //结果:0
}
}
为什么这个a/b等于0呢?
因为a是int型的b也是int型的,他们两个除完还是int型的,他们的值应该等于0.5,但是被整数形类型限制住了,只能舍去小数,所以等于0;所以我们不能这样写,我们要随便对一个进行强制类型转换,System.out.println(a/(double)b);
演示 4种整数类型相加的情况
public class Demo15{
public static void main(String[] args){
long a = 123123123123123L;
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类型
}
}
得出结果:
- 多个操作数中,有一个数为long类型,那么这个结果类型也为long
- 如果多个操作数中,没有一个数为long类型,那么结果的类型都为int
我们再来看一下其他基础数据类型类型:
public class Demo16{
public static void main(String[] args){
double a = 0.3;
int b = 3;
char c = 'a';
System.out.println(a+b); //结果:3.3为浮点型
System.out.println(a+c); //结果:97.3为浮点型
System.out.println(b+c); //结果:100为整形
}
}
得出结果:
- 不同基本的相加最终得出的结果的类型,取决于操作数中在类型转换中较高优先级的类型
- 我能大胆的告诉你-,*,/也是这样的;但是也会遇下面这两种种情况:
public class Demo17{
public static void main(String[] args){
int a = 3;
int b = 6;
char c = 'a';
System.out.println(a/c); //结果为0
System.out.println(b/c); //结果为0
}
}
那么这两种情况与上面 演示 加减乘除:这种情况是一样的
关系运算符
关系运算符只有两种返回结果:正确和错误,就是通过布尔值来表示的
public class Demo18{
public static void main(String[] args){
int a = 10;
int b = 20;
System.out.println(a>b); //false
System.out.println(a
后期会经常与if去使用!
取余、自增自减运算符、初识Math类
取余、模运算
public class Demo19{
public static void main(String[] args){
int a = 10;
int b = 21;
System.out.println(b%a);//结果为1
}
}
就像我们小学学的余数21/10=2……1;取余就是要这个余数;也叫模运算+
自增、自减(一定要理解起来)
这个比较难理解,但是我会讲的通俗一点
public class Demo20{
public static void main(String[] args){
// ++ -- 自增、自减 一元运算符
int a = 3;
int b = a++;
int c = ++a;
System.out.pringln(a); //5
System.out.pringln(b); //3
System.out.pringln(c); //5
}
}
为什么会是这样的结果呢?
原因就在++的位置:
int b = a++;
++在后面:先给b进行赋值,再进行自增
就是说a初始值是3;int b = a++;这句是先把初始值3赋值给b之后,然后再进行a=a+1;
int c = ++a;
++在前面:先进行自增,再进行赋值
就是说现在a的值是4,int c = ++a;这句是先进行a=a+1;之后a值为5,再把5赋值给c
自减也是这样的!
初识Math
public class Demo21{
public static void main(String[] args){
//幂运算 2^3 2*2*2 = 8
//java中是像下面这样写的;我们会借助到数学类Math
double pow = Math.pow(2,3); //这样是表示2的3次方
System.out.println(pow); //8.0
}
}
在java中,很多运算,我们会使用一些工具类来操作!
逻辑运算符、位运算符
逻辑运算符
public class Demo22{
public static void main(String[] args){
// 与(and) 或(or) 非(取反)
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a&&b)); //a && b:false
//逻辑与运算:两个变量都位true,结果才为true
System.out.println("a || b:"+(a||b)); //a || b:true
//逻辑或运算:两个变量有一个位true,结果才为true
System.out.println("! (a && b):"+!(a&&b));//! (a && b):true
//逻辑非运算:对结果进行取反,如果结果为真则变为假,结果为假,则变为真
}
}
- 逻辑与运算:两个变量都位true,结果才为true
- 逻辑或运算:两个变量有一个位true,结果才为true
- 逻辑非运算:对结果进行取反,如果结果为true则变为false,结果为false,则变为true
短路运算
public class Demo23{
public static void main(String[] args){
//短路运算
//因为逻辑与运算需要两个变量都为真结果才为真
//这样的话是不是第一个为假第二个就不会执行了?下面我们来实验一下
int a = 5;
boolean b = (a
短路法则:
变量1 && 变量2
变量1为”假”,则变量2不会再执行;
否则,变量1″真”,则变量2必须执行。
变量1 || 变量2
变量1为“真”,则变量2不会再执行;
否则,变量1“假”,则变量2必须执行。
位运算符
别轻易去用位运算,很容易出错
$ | ^ ~位运算符里面的 位与、位或、位异或、位非(其中只有位非(~)是一元操作符,其他都为二元操作符)
public class Demo24{
public static void main(String[] args){
/*
布尔值:false即是0,true即是1
比如我们现在有两个值
A = 0011 1100
B = 0000 1101
A&B
位与运算符:A与B上面的和下面对其的都为1那么结果为1,否则为0;结果:0000 1100
也就是说两者对其位都为true则结果为true,否则为false
A|B
位或运算符:A或B的对其位其中有一个为1那么结果为1,否则为0;结果0011 1101
也就是说两者对其位只要有一个为true结果就为true,否则为false
A^B
位异或运算符:对其位不同即为1,相同则为0;结果:0011 0001
也就是对其位不相同为true,相同则为false
~B
位非运算符:就是取反,1取反为0,0取反为1;结果:1111 0010
也就是说如果为true就取反为false,为false取反为true
*/
}
}
< (涉及到一道面试题)
public class Deomo25{
public static void main(String[] args){
/*
常见的一道面试题
问:2*8怎么算最快
2*8大家都都可以直接知道等于16,但是计算机不知道
我们先来做一下这道题:
*/
System.out.println(2<
得出结果:
<
- 把这个结果死死记载心里
- 我们现在虽然接触不到算法,但是很多底层的算法它们会用位计算来做一些非常精巧的东西,因为位运算有一个好处:效率极高;因为它是直接跟底层打交道的,底层说的就是这个二进制
所以2*8在计算机中这么算最快:2<
Original: https://www.cnblogs.com/xiaodi-CISP-PTE/p/15957915.html
Author: XiaoDi_CISP-PTE
Title: 四、Java基础
原创文章受到原创版权保护。转载请注明出处:https://www.johngo689.com/580990/
转载文章受原作者版权保护。转载请注明原作者出处!