Java基础学习

Java

cmd

盘符名称+冒号 盘符切换 如 D:回车 切换到D盘

dir 查看当前路径下的内容

cd 目录 进入单极目录 cd source

cd .. 回退到上一级目录

cd 目录1\目录2 进入多级目录

cd \ 回退到盘符目录

cls 清屏

exit 退出命令提示符窗口

环境变量：我们在使用cmd时，想运行某个程序，如果在我们现在这个盘符文件夹内找不到这个程序，系统就会到环境变量里面从上往下去找，所以我们就可以把这个程序的路径放在环境变量path里面，这样我们在任意文件夹里面都可以去打开这个指定的程序

也可以新建系统变量,变量值不带最后一个文件夹,然后再在Path里面去加入最后一个文件夹的名称方法如%变量名%\文件名

我们用javac(jdk提供的编译工具把.java文件编译成.class文件)去编译，用java(jdk提供的运行代码的工具)去运行

在cmd里面找到我们编写代码的文件夹

用 javac 代码文件.java 运行，编译得到 代码文件.class

再通过 java 代码文件(不带后缀) 运行代码

public class 类名(类名得和文件名一致){

public static void main(String [] args){

System.out.println();

}

}

字面量

整数 123 321 -333

小数 1.23 3.21 6.66

字符串 "学会java"

字符 '嘿'

布尔 true false

空 null (null不能直接打印)

特殊字面量

制表符 \t : 在打印的时候,把前面的字符串的长度补齐到8,或者8的整数倍.最少补一个空格,最多补8个空格.

数据类型

基本数据类型

关键字 取值范围 内存占用

byte -128~127 1

short -32768~32767 2

int -2147483648~2147483647(10位数) 4

long (19位数) 8

在使用long的时候得在变量后面加一个L,大小写都可以,建议用大写的L

folat -3.401298e-37~3.402823e+38 4

在使用float的时候也得在变量后面加一个F后缀

double -4.9e-324~1.797693e+308 8

char 0~65535 2

boolean true,false 1

取值范围 double>folat>long>int>short>byte

基本数据类型:数据值存储在自己的空间里面,给别人赋值的是真实的值

引用数据类型:数据值存储在其他空间.自己空间存储的是其他空间的地址,给别人赋值的是地址值.

标识符

由数字,字母,下划线(_)和美元符号($)组成

不能以数字开头

不能是关键字

区分大小写

Scanner类

步骤:

1. 导包 (写在类定义上面) import java.util.Scanner;

2. 创建对象 Scanner sc = new Scanner(System.in);

3. 接受数据 int i = sc.nextInt();

IDEA项目结构

project(项目),module(模块),package(包),class(类)

psvm快速生产主函数

sout快速生成输出语句

运算符

算术运算符

+,-,*,/,%

当两个不同类型的数据进行运算的时候,得先进行转换成同一类型,再进行运算.

byte,short,char在进行运算的时候自动转换成int

隐式转换:

小的数据和大的数据进行运算的时候,会把小的数据自动转换成大的数据的数据类型

强制转换:

把一个取值范围大的数据,赋值给取值范围小的数据,得用强制转换

目标数据类型 变量名 = (目标数据类型) 被强制转换的数据

字符串的"+"操作

当"+"操作中出现了字符串,这个"+"就变成了字符串连接符,而不是算术运算符,把前后的数据进行拼接,产生一个新的字符串.

连续的"+"操作就是从左到右逐个执行.

1 + 51 + "你" = 52你

先进行算术运算1 + 51 再进行52和"你"的拼接.

当 "字符＋字符" 或者 "字符 + 数字" 时,会把字符通过ascll码表查询到对应的数字再进行计算.

ascll "0" 48 "A" 65 "a" 97

'a' + 1 = 98 char先自动转换成int 再进行加法

自增运算符 ++

自减运算符 --

b = a++ 就是先把a赋值给b再对a进行++操作

b = ++a 就是先对a进行++操作,在给b赋值

赋值运算符

= , += ,-= ,*= ,/=;

关系运算符

==,!+,>,>=,<,<=;成立为true ,不成立为false

逻辑运算符

&,|,^,!;

^异或运算,两边相同为false,相异为true

短路运算符;

&& a && b

先判断a 成立吗,a成立才回去看b成立不成立

如果a不成立,就不会去看b成立不成立

|| a||b

两边都是假结果才为假,先判断第一个是不是假,如果不是假,对第二个的判断就不再进行了,而|运算符会对两边都进行判断

三元运算符

格式:关系表达式?表达式1:表达式2;

如果关系表达式为真,那么得到的就是表达式1;

关系表达式为假,得到的就是表达式2;

运算符的优先级 ()优先于所有的符号

原码,反码,补码

源码:十进制数据的二进制表现形式,最左边是符号位,1为负,0为正.

原码对正数计算不会有问题,但是对负数进行计算,结果就会出错,实际运算的结果和我们预期的结果是相反的.

反码:为了解决不能计算负数的问题而出现的.

计算规则:正数的反码不变,负数的反码在原码的基础上,符号位不变,数值取反,0变1,1变0.

在反码里面,0有两种表达方式,在计算跨0的算式时,会有误差

补码:把反码加1,计算机里面数据的储存就是靠补码来进行储存的.

正数的原码,补码,反码都相同.

判断和循环

case 穿透

如果匹配上了,就会执行这个语句体,然后找到break,如果找不到break,就会继续执行下一个语句体,直到找到break.

switch 新特性 jdk12

case ->{}

default ->{}

匹配上了就会执行大括号里面的语句

switch匹配具体数据,if else 匹配范围的数据

for(初始化语句;条件判断语句;条件控制语句){

循环体语句;

}

初始化语句;

while(条件判断语句){

循环体语句;

条件控制语句;

}

无限循环

for(;;){

}

while(true){

}

do{

}while(true);

数组

数组指的是一种容器,可以用来储存同种数据类型的多个值.

数组的静态初始化

数据类型[] 数组名 = new 数据类型[]{元素1,元素2..};

数据类型[] 数组名 = {元素1,元素2..};

数组名.length获取数组的长度

数组的动态初始化:

数据类型[] 数组名 = new 数据类型[数组长度]

整数默认初始化0,小数0.0,字符是'\u0000'空格,布尔是false,引用数据类型是null

二维数组

数组类型 [] [] 数组名 = new 数组类型 [] []= {{},{}};

int [] [] arr = {

{1,2,3},

{3,4,5,6,7}

}

方法

public static void 方法名(参数){

方法体;

}

参数之间用逗号隔开,且参数的数量和类型得一一对应

带有返回值的方法

public static 返回类型 方法名(参数){

方法体;

return 返回值;

}

在调用处要根据方法的结果,去编写另外一段代码.就得用到有返回值的方法

方法在main方法里面调用,在main方法外面编写

方法的重载:相同的方法具有不同的参数,可以用相同的方法名.

参数不同:个数不同,类型不同,顺序不同;

java虚拟机会通过参数的不同来找到不同的方法.

只判断两个:是不是在同一个类且方法名是不是相同,然后参数是不是相同,与返回值的类型无关.

面向对象

面向对象编程就是利用对象来完成我们的目的.

public class 类名{

1.成员变量

2.成员方法

3.构造器

4.代码块

5.内部类

}

描述一些列事物的类叫做javabean类

带有main函数的类叫做测试类

面向对象三大特征:继承,多态,封装;

封装:告诉我们如果正确地去设置对象的属性和方法

对象代表什么,就封装相应的数据,并且提供数据对应的方法

private关键字:

权限修饰符,可以修饰成员,被修饰的部分只能在本类类名被访问

就近原则:

当局部变量和成员变量名字相同时,就会一句就近原则,谁离他近就用哪个变量.

如果要运用成员变量,外面就可以用this.来调用.

构造方法:构造器,构造函数(初始化对象)

构造方法要与类名相同,大小写也得一致,并且他没有返回值,每创建一个对象,构造方法就得调用一次.

如果没有定义构造方法,系统就会给出一个默认的无参的构造方法.

标准javabean类:

1.类名要见名知意.

2.成员变量使用private修饰

3.提供至少两个构造方法(无参,全参)

4.成员方法(每个成员变量的get与set)

快捷键 alt+insert或者alt + fn +insert

ptg构造javabean

接收数据

next();接收字符串

nextInt();接收整数

nextdouble();接收小数

前面三个遇到空格,制表符就不会再输入

nextline();接收字符串,只有遇到回车才会停止输入

上面和下面是不能混用的,混用会先用next再用nextline(),把next剩余的留给nextline();

API

应用程序编程接口

Scanner random都是API中的一部分

API帮助文档

string字符串

使用new创建字符串

string s1 = new string();

可以空参构造形成空字符串,也可以在括号里加字符串创建字符串,还有加入字符数组来创建字符串(比如说字符串不能改变,但是字符数组可以改变,使用我们可以通过改变字符数组再去改变字符串)

加入byte数组,会先去找acsll码找到对应的字符形成字符串

string s1 = new string( char [] chs);

直接创建的话存储在string table(串池)如有重复的数据就不会再次创建,而是进行数据复用

==号的比较原理:

如果是基本数据类型,就是直接比较数据值

如果是引用数据类型,比较的是地址值

两个string 的比较方法

boolean euqals() 完全比较

boolean equalsIgnoreCase()忽略大小写

boolean result = s1.euqals(s2);

键盘录入的字符串是new出来的

public char charAt(int index);根据索引返回字符

public int length();返回字符串的长度

数组的长度:数组名.length

字符串长度:字符串对象.length();

string builder 可以看成一个容器,创建后里面的内容是可以变的,提高字符串的操作效率

用于拼接字符串和反转字符串

stringbuilder (string str)初始化

stringbuilder append()添加数据,并返回对象本身

stringbuilder reverse()反转容器的内容

length() 返回长度

string tostring() 把stringbuilder转换成string

stringbuilder在java里面被处理过了,打印出来的是里面的内容而不是地址值.

链式编程,依靠前面代码的结果来完成后面的代码

stringjoiner 和stringbuilder一样,也可以看成一个容器创建的内容是可以改变的

用于高效的拼接字符串

stringjoiner(间隔符号,开始符号,结束符号) 开始和结束可以不写

stringjoiner add(添加的内容)

length()

stringjoiner tostring()

string使用+拼接,如果没有变量就不会创建新的对象

有变量的话就会new一个stringbuilder去完成拼接

字符串变成数组 char[] arr=str.tocharArray();

集合

数组的长度是固定的,但是集合的长度是可以变化的

集合只能存储引用数据类型,如果要存储基本数据类型得变化成它对应的包装类才行. ArrayList<E> 泛型 用来限定集合存储的内容

ArrayList<string> list = new ArrayList<>();

在展示的时候会在两边形成[]来包围数据

增删改查

add

E remove(int index) 返回值是删除的索引对应的元素

E remove (e);

E set(int index,e)

get(int index)

int size()

包装类

char Character

int Integer

其它的就是首字母大写

ctrl alt +t 可以用代码包裹选中的代码如while包裹代码

break只能跳出一层循环,所以我们可以给循环起一个名字

如 loop: while(true){

break loop;

}

就能在嵌套循环里面结束外层循环

或者system.exit(0) 停止虚拟机运行来关闭循环

面向对象进阶

static 静态,是java里面的一个修饰符,可以修饰成员方法,变量

静态变量:被该类的所有对象共享

static string name;

类名.name来赋值比对象名.name赋值更适合

static修饰的是优先于对象出现的,在类船创建的时候就创建好了

静态变量储存堆内存的静态区里面

静态方法

多用在测试类和工具类中

工具类:用来帮我们做一些事情而补描述任何事情

得私有化构造方法 ,把方法定义为私有的

类名调用(推荐)

静态方法只能访问静态变量和静态方法

而非静态方可以访问静态的也可以访问非静态的,且静态方法没有this指针

继承

java提供关键字extends让两个类建立起继承关系

public class 子类 extends 父类{}

子类(派生类) 父类(基类或超类)

类与类之间有共性,子类是父类的一种,就可以考虑使用继承来优化代码

java只支持单继承,不支持多继承,但是支持多层继承

所有类都直接或者间接继承与object(没有父类默认继承object)

子类不能访问private的内容

子类的构造方法不能继承父类的

子类可以继承到父类的变量,但是不能直接使用,私有的可以通过get方法获取父类继承的私有变量的值.

虚方法表:非private,非static,非final

在继承的时候会把虚方法表交给子类,提高性能

在调用方法的时候会找到方法在不在虚方法表里面,如果在直接调用,使用能放在虚方法表里面的方法就能被子类继承

就近原则,在继承方面也有体现

三个区别的方式是name,this.name,super.name

当父类的方法不能满足子类的需求时进行重写

重写的子类的返回值的范围得小于等于父类的范围

方法重写后会对虚方法表里面原来继承来的方法进行覆盖

不能添加在虚方法表里面的方法不能被重写

子类中所有的构造方法默认先访问父类的无参构造,再执行自己的

因为子类初始化的时候有可能会使用到父类的数据,如果父类没有完成初始化,子类将无法使用父类数据

子类构造方法的第一行语句默认是super(),不写也纯在,且必须再第一行,如果想调用父类的有参构造,得自己通过super调用父类的带参构造

public student (string name, int age){

super(name,age);

}

可以通过this()来调用本类的其他构造,使用可以再空参构造里面用this(name:null,age:0,school:"东北大学");去传默认值

多态

同种类型的对象,表现出的不同形态

多态的表现形式 父类类型 对象名称 = 子类对象;

多态的前提:有继承关系,有父类引用指向子类对象,有方法重写

多态能通过你传入的不同对象类型调用不同类型的方法

使用父类作为参数,可以接受所有子类的数据

成员变量调用:编译看左边,运行看左边

javac编译代码时会看左边父类有没有这个变量,有才会编译成功

java运行的时候获取的是左边父类的值

方法调用:编译看左边,运行看右边

javac编译代码时会看左边父类有没有这个方法,有才会编译成功

java运行的时候运行的是右边子类的方法

在多态形式下,右边对象可以实现解耦合,便于扩展和维护

定义方法的时候用父类作为参数,就可以结束所有的子类对象,实现多态的扩展性和便利性

多态的弊端:不能调用子类的特有功能,子类的特有方法不能调用,因为父类里面没有.

可以通过关键字 if (变量名 instanceof 类名)去判断一个变量是不是这个类

if (a instance dog d) 判断a是不是dog类型,如果是那就强制转换成dog 类型,变量名为d,如果不是结果是false不再进行强转

包

包就是文件夹,用来管理各种不同功能的java类

包名规则:公司域名反写+包的作用,需要全部英文小写,见名知意

使用其他类的时候,需要使用全类名

导包就可以减轻使用其他类时代码的书写量

在同一个包中的类不需要进行导包,使用java.lang包中的类时不需要进行导包,其它情况都需要导包,如果使用两个类名相同的类时,都得使用全类名

final

使用final后就不能再改变了

final能够修饰方法,类,变量

修饰方法,表示该方法是最终方法,不能被重写

如果这个方法是规则,不想被改变,就可以用final修饰

修饰类,表名该类是最终类,不能被继承

修饰变量,叫做常量,只能被赋值一次

常量:

单个单词大写,多个单词全部大写,单词间用下划线隔开

final修饰的变量是基本类型,那么变量储存的数据值不能改变

final修饰的变量是引用类型,那么变量储存的地址值不能改变

字符串是不能改变的原因就是有final修饰

权限修饰符

控制一个成员能被访问的范围

可以修饰成员变量,方法,构造方法,内部类

四种权限修饰符作用范围

private>缺省(默认不写)>protected>public

private 只能自己类类名用

默认 只能本包里面使用

protected 其它包的子类也能用

public 谁都可以用

如果方法中的代码是抽取其它方法中共性的代码,这个方法一般也私有

代码块

局部代码块

写在方法里面的单独的{}

作用:提前结束{}里面的变量的生命周期

构造代码块

构造方法重复的部分就可以写在构造代码块中

构造代码块优先于构造函数执行

构造代码块一般不使用,重复代码可以写个方法来操作,或者写在有参构造函数里面,在空参构造函数里面用this方法去调用

静态代码块

static{}

随着类的加载而加载,自动触发且只执行一次

在类加载,做一些数据初始化时可以使用静态代码块

抽象类

抽象方法:把共性的行为抽取到父类后,每个子类执行的内容不一样,使用父类中不能确定具体的方法体,该方法就可以定义为抽象方法

如果一个类里面有抽象方法,那么该类必须声明为抽象类

public abstruct 返回值类型 方法名(参数);

public abstruct 类名{}

抽象类不能创建对象,抽象类不一定有抽象方法,但是又抽象方法一定是抽象类

子类要么重写抽象类的所有抽象方法,要么就是抽象类

子类强制重写

接口

接口就是一个规则,是对行为的抽象,多个类有这个规则就可以写出一个接口

public interface 接口名{}

接口不能实例化

接口和类之间是实现关系,通过implements关键字表示

public class 类名 implements 接口名{}

接口的子类是实现类

InterImpl ii = new InterImpl();

接口和类的实现关系,可以是单实现也可以是多实现

public class 类名 implements 接口1,接口2{}

实现类还可以在继承一个类的同时实现多个接口

public class 类名 extends 父类 implements 接口1,接口2{}

接口成员变量只能是常量,默认修饰符public static final

接口没有构造方法(系统默认的空参构造也没有)且只能写抽象方法

接口和接口之间是继承关系,可以单继承也可以多继承,如果实现类实现了最下面的子接口,所有体系的方法都得重写

接口发生了变化,下面的实现这个接口的代码不进行改变就会报错

解决接口升级的问题:允许在接口中定义默认方法,使用关键字default修饰. public default 返回值类型 方法名(参数列表){}

默认方法不是抽象方法,不强制重写,如果要重写,就得在重写的时候去掉default关键字

但是如果有多个接口,存在相同名字的默认方法,子类就必须对该方法进行重写

接口中静态方法,只能通过接口名调用

抽取出来的重复部分,可以放在私有方法类名;

静态私有方法给静态方法服务

当一个方法的参数是接口时,可以传递接口所有实现类的对象,称为接口多态

适配器:中间写一个接口作为适配器,方法全部重写空实现,再创建实现类,在实现类里面重写我们需要的那一部分方法.为了防止其他类创建适配器的对象,使用适配器通过abstruct修饰

内部类

在一个类的类名在定义一个类

内部类表示的事物是外部类的一部分且内部类单独出现没有任何意义

内部类能直接访问外部类的成员,包括私有

外部类要访问内部类,必须创建对象

外部类名.内部类名 对象名 = 外部类对象.内部类对象;

Outer.Inner oi = new Outer().new Inner();

_是给常量用的$是给内部类用的

成员内部类

写在成员位置,属于外部类的成员

成员内部类能被修饰符修饰,规则和成员变量一样

外部了IC元变量名和内部类成员变量名重名的时候使用Outer.this.a调用外部类的成员变量

静态内部类

静态内部类只能访问外部类中的静态变量和静态方法,如果要访问非静态的需要创建外部类的对象

静态对象创建

外部类名.内部类名 对象名 = new 外部类名.内部类名();

静态方法格式

外部类名.内部类名.方法名();

主要是静态的东西都可以直接使用 类名. 来直接获取

局部内部类

定义在方法里面的,类似于方法里面的局部变量

外界是无法直接使用,需要在方法内部创建对象并使用

该类可以直接访问外部类的成员,也可以访问方法内的局部变量

匿名内部类

格式

new 类名或者接口名(){

重写方法;

};

匿名类能够让我们不需要创建子类就能调用方法

在创建单次使用的对象时提高代码的可读性和易维护性

创建的匿名类就能看成是类的子类,所以匿名类可以在直接创建对象的时候实现接口,并提供接口方法的具体实现