##java语言的基本语法
编写java程序时，应注意以下几点：
- 大小写敏感：这就意味着hello与Hello是不同的
- 类名：对于多有的类来说，类名的首字母应该大写，如果类名由若干单词组成，那么每个单词的首字母应该是大写。
- 方法名：所有的方法名都应该有小写字母开头，如果方法名含有若干单词，则后面的单词首字母大写
- 源文件名：源文件名必须与类名相同。文件名的后缀应该是.j
- ava 主方法入口：所有的java程序由public static void main(String []args)方法开始执行
java中&与&&的区别java中&与&&的区别
1. 最简单的区别是，&无论str != null 是否为true，程序都会执行，而&&只有在str != null 为true时，程序才会执行，为false时，程序处于短路状态
3. &左右两边有一个符号为false时，结果为false，两边符号都为true时，结果才为true。而&&只要左边的符号为false，那么结果就是false，右边的符号为true，结果就是true。
5. &无论左边是否为false，它他都会检验右边的boolean值，而&&只要检测到左边的boolean值为false，就不会再检测右边的boolean值。
7. 总的来说&&执行效率要比&高一些，也更准确一些，所在在编写程序时，&&的使用率要比&高。访问修饰符
详细介绍可移步到https://www.runoob.com/java/java-modifier-types.html 进行查看
- default (即缺省，什么也不写，不使用任何关键字）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
- protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
- public : 对所有类可见。使用对象：类、接口、变量、方法
Java的内部类可以有四种访问修饰符bai public, private, protected和default, ，但是除内部类外，du类的修饰符只能是public 或 default；语法设计上就是这样的，至zhi于为什么，就只能问设计者了。
对于接口而言，其修饰符只能用public、default和abstract， 不能用final、static修饰。接口默认修饰为abstract。
接口中的方法修饰符，只能使用public和abstract，默认也是public abstract。 需要说明的是：自Java1.8以后，接口允许定义静态方法，也就是说你可以用static来修饰接口中的方法了。
##重载与重写的区别
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PFBZPVX9-1596610275260)(http://api.axclouds.com:4999/server/…/Public/Uploads/2020-08-01/5f2525842f6a4.png)]
### 我们先从定义上区分重载和重写：
1.重载（overload）是发生在同个类中的具有相同的方法名，不同的参数类型（不同的参数类型包括：参数的个数和参数的类型和顺序不同），返回值相同或者不同的一种多态的体现。从返回值类型相同或者不相同可以看出，我们不能根据方法的返回值来判断是否为重载。
2.重写（override）发生在子父类中，方法名相同参数列表相同，返回值类型相同。体现了父类和子类之间的多态性。子类继承父类后拥有父类非private限定的属性和方法，如果子类不想原封不动的运用父类的继承过来的方法，这时候就要需要对方法进行重写。
（1）：子类不能重写父类中被finall修饰的方法。
（2）：子类必须重写父类中的抽象方法（abstract修饰的方法）
（3）：子类不能继承父类被private修饰的属性和方法
（4）：子类不能继承父类的构造器
面向对象（中） 理解有参构造器和无参构造器的作用
一、概念
java中构造方法指的是：
与类名相同，无返回类型的方法，参数可以为空，也可以带参数。
比如一个 Dao 类，private Dao(){}这个就是无参数的构造方法。
private Dao(String name){}这个就是带参数的构造方法。
作用：用来初始化 java 类，提供类的初始化和实例化，以便调用。
二、作用
new一个对象的时候要用到构造函数,例如Hello hello = new Hello();这时调用的是Hello的无参数构造方法;Hello hello = new Hello(“hi”);这个是调用Hello有参数构造方法,在JAVA中如果不写构造方法的话,会默认加上一个无参数的构造方法,但是如果已经有了一个有参数的构造方法,那么无参数的构造方法就不会默认被加上.如果Hello类中已经有了一个有参数的构造方法,这时再使用Hello hello = new Hello();来创建对象的时候就会出错,这就是为什么书上要强调写了有参数的构造方法就最好加一个无参数的构造方法。
三、区别
有参数的构造方法的主要目的是为类中的属性初始化的，而无参数的构造方法,可以控制new对象。
假设你的午餐构造方法不是public 修饰 而是project ，
那么别人将不只能直接new一个对象,这就起到了控制作用。
为什么要自动生成无参构造呢?
你没有构造方法就不能new出对象 所以就给你生成一个无参构造方法
一般构造方法就是来控制你new对象的 还有就是初始化属性
Java中Static的作用
1、修饰成员方法
在Java程序里面，所有的东西都是对象，而对象的抽象就是类，对于一个类而言，如果要使用他的成员，那么普通情况下必须先实例化对象后，通过对象的引用才能够访问这些成员，但是有种情况例外，就是该成员是用static声明的.
在java类库当中有很多类成员都声明为static，可以让用户不需要实例化对象就可以引用成员，最基本的有Integer.parseInt()，Float.parseFloat()等等用来把对象转换为所需要的基本数据类型。这样的变量和方法我们又叫做类变量和类方法。（在这里所讲排除了类的访问控制）,例子如下：
** a：未声明为static **
class ClassA{
int m;
public void method1(){
......
}
}
class ClassB{
void method2{
int i;
ClassA classa = new ClassA();
i = class_a.n; 这里通过对象引用访问成员变量m
classa.method1; 这里通过对象引用访问成员函数method1
}
}b：声明为static
class ClassA{
static int m;
static void method1(){
......
}
}
class ClassB{
void ex2{
int i;
i = ClassA.m; 这里通过类名直接访问成员变量m
ClassA.method1; 这里通过类名直接访问成员函数method1
}
}2、修饰成员变量
给变量加上static关键字后，此变量变为全局变量，在编译时由内存分配一块内存空间，直到程序停止运行才会释放,无论哪一个方法修改了此变量，此变量就会改变，那么就是说该类的所有对象都会共享这块内存空间。并且，当再次new该类的对象时，static修饰的类成员不会被再次初始化，在程序运行过程中，static只会在第一次new时被初始化.例子如下：
class TextStatic{
static int i;
public TextStatic(){
i = 4;
}
public TextStatic(int j){
i = j;
}
public static void main(String args[]){
TextStatic t = new TextStatic(5); //声明对象引用，并实例化
TextStatic tt = new TextStatic(); //声明对象引用，并实例化
System.out.println(t.i);
System.out.println(tt.i);
System.out.println(t.i);
}
}
这段代码里面TextStatic类有一个static的int变量i，有两个构造函数，第一个用于初始化i为4，第二个用于初始化i为传进函数的
值，在main中所传的值是5，程序首先声明对象的引用t，然后调用带参数的构造函数实例化对象，此时对象t的成员变量I的值为
5，接着声明对象tt，调用无参数的构造函数，那么就把对象tt的成员变量i的值初始化为4了，注意了，在这里i是static，那就是说
该类的所有对象都共享该内存，那也就是说在实例化对象tt的时候改变了i的值，那么实际上对象t的i值也变了，因为实际上他们引
用的是同一个成员变量。最后打印的结果是三个4。3、静态代码块：
当new一个类对象时，static修饰的成员变量首先被初始化，随后是普通成员，最后调用Person类的构造方法完成初始化。也就是说，在创建对象时，static修饰的成员会首先被初始化
并且，当再次new该类的对象时，static修饰的类成员不会被再次初始化，在程序运行过程中，static只会在第一次new时被初始化
4、静态导包：
静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。
5、代码块：
代码块分为两种种：普通代码块，静态代码块。他们和构造函数的运行顺序如下所示：
静态块总是最先执行的，第二执行的是普通代码块，第三执行的是构造方法。并且构造块和构造方法在每次new的时候都会创建新的，static方法只会在第一次new时运行
6、静态使用时需要注意的事项：
- 静态方法只能访问静态成员。（非静态既可以访问静态，又可以访问非静态）
- 静态方法中不可以使用this或者super关键字。
- 主函数是静态的
java能否支持多继承？
在java中，原则上是不允许多继承的，也就是类与类之间只可以单继承。
当然，实现多继承可以通过两种方式：
1：接口
接口是常量值和方法定义的集合。接口是一种特殊的抽象类。
java类是单继承的。classB Extends classA
java接口可以多继承。Interface3 Extends Interface0, Interface1, interface……
不允许类多重继承的主要原因是，如果A同时继承B和C，而B和C同时有一个D方法，A如何决定该继承那一个呢？
但接口不存在这样的问题，接口全都是抽象方法继承谁都无所谓，所以接口可以继承多个接口。
注意：
1）一个类如果实现了一个接口，则要实现该接口的所有方法。
2）方法的名字、返回类型、参数必须与接口中完全一致。如果方法的返回类型不是void，则方法体必须至少有一条return语句。
3）因为接口的方法默认是public类型的，所以在实现的时候一定要用public来修饰（否则默认为protected类型，缩小了方法的使用范围）。2：使用内部类实现多继承
(关于内部类的详细介绍可参考“浅谈Java内部类”文档)
class Example1 {
public String name()
{
return "liutao";
}
}
class Example2 {
public int age()
{
return 25;
}
}
class MainExample
{
private class test1 extends Example1
{
public String name()
{
return super.name();
}
}
private class test2 extends Example2
{
public int age()
{
return super.age();
}
}
public String name()
{
return new test1().name();
}
public int age()
{
return new test2().age();
}
public static void main(String args[])
{
MainExample mi = new MainExample();
System.out.println("姓名:" + mi.name());
System.out.println("年龄:" + mi.age());
}
}Java的八大基本数据类型
定义：Java语言是强类型语言，对于每一种数据都定义了明确的具体的数据类型，在内存中分配了不同大小的内存空间。
分类
1:基本数据类型
数值型
整数类型(byte,short,int,long)
浮点类型(float,double)
字符型（char)
布尔型（boolean)
2:引用数据类型
类(class)
接口(interface)
数组([])
关系图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c7RhUMBi-1596610275264)(http://api.axclouds.com:4999/server/…/Public/Uploads/2020-08-02/5f26629131d88.png)]
Java和C++的区别
我知道很多人没学过C++，但是面试官就是没事喜欢拿咱们Java和C++比呀！没办法！！！就算没学过C++，也要记下来！
- 都是面向对象的语言，都支持封装、继承和多态
- Java不提供指针来直接访问内存，程序内存更加安全
- Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是接口可以多继承。
- Java有自动内存管理机制，不需要程序员手动释放无用内存
JVM、JRE、JDK之间的关系
JDK（java development kit）
JDK是Java开发工具包,是整个Java的核心，包括了Java运行环境JRE、Java工具和Java基础类库。
JRE（java runtime environment）
JRE是Java的运行环境，包括JVM标准实现及Java核心类库。
JVM（java virtual machine）
JVM是java虚拟机，是整个java实现跨平台的最核心的部分，能够运行以Java语言写作的软件程序。
三者的关系
JDK=JRE+其他
JRE=JVM+其他
什么是跨平台性？原理是什么
所谓跨平台性，是指java语言编写的程序，一次编译后，可以在多个系统平台上运行。
实现原理：Java程序是通过java虚拟机在系统平台上运行的，只要该系统可以安装相应的java虚拟机，该系统就可以运行java程序。（注意不是能在所有的平台上运行，关键是该平台是否能安装相应的虚拟机）。
我的理解：Java程序之所以能够实现跨平台运行，是因为它根本就不直接运行在任何底层平台上，而是需要在哪里运行，就在哪里(如Windows平台)事先准备好自己的Java平台，而这只是仅仅是安装和配置一个软件而已！
Java语言的特点
- 特点一：面向对象
两个基本概念：类、对象
三大特性：封装、继承、多态 - 特点二：健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与
释放等），提供了一个相对安全的内存管理和访问机制 - 特点三：跨平台性
跨平台性：通过Java语言编写的应用程序在不同的系统平台上都可以运行。“Write
once , Run Anywhere”
原理：只要在需要运行 java 应用程序的操作系统上，先安装一个Java虚拟机 (JVM Java
Virtual Machine) 即可。由JVM来负责Java程序在该系统中的运行。
Java语言的特点：跨平台性
switch支持的数据类型
switch case 分支结构 如下：
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}expression支持的数据类型
- 基本数据类型：byte, short, char, int
- 包装数据类型：Byte, Short, Character, Integer
- 枚举类型：Enum
- 字符串类型：String（Jdk 7+（JDK1.7之后） 开始支持
- 不支持boolean和double型
枚举
java注解
用于解释说明程序的文字,作用:
在程序中，尤其是复杂的程序中，适当地加入注释可以增加程序的可读性，有利于程序的修改、调试和交流。注释的内容在程序编译的时候会被忽视，不会产生目标代码，注释的部分不会对程序的执行结果产生任何影响。
注意事项：多行和文档注释都不能嵌套使用。
单行注释
格式： // 注释文字
多行注释
格式： /* 注释文字 */
文档注释
格式：/** 注释文字 */Java 有没有 goto
goto 是 Java 中的保留字，在目前版本的 Java 中没有使用。
##final 有什么用？
用于修饰类、属性和方法；
- 被final修饰的类不可以被继承
- 被final修饰的方法不可以被重写
- 被final修饰的变量不可以被改变，被final修饰不可变的是变量的引用，而不是引用指向的内容，引用指向的内容是可以改变的
final finally finalize区别
final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表
示该变量是一个常量不能被重新赋值。
finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块
中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调
用，当我们调用System.gc() 方法的时候，由垃圾回收器调用finalize()，回收垃圾，一个对象是否可回收的
最后判断。
final有什么用？
用于修饰类、属性和方法：
- 被final修饰的类不可以被继承
- 被final修饰的方法不可以被重写
- 被final修饰的变量不可以被改变，被final修饰不可变的是变量的引用，而不是引用指向的内容，引用指向的内容是可以改变的
java中::的用法实例
public class mytest {
public static void printValur(String str) {
System.out.println("print value : " + str);
}
public static void main(String[] args) {
List<String> al = Arrays.asList("a", "b", "c", "d");
al.forEach(mytest::printValur);
}
}Java开发中抽象类和接口都有什么区别？
抽象类：1、抽象类使用abstract修饰；2、抽象类不能实例化，即不能使用new关键字来实例化对象；3、含有抽象方法（使用abstract关键字修饰的方法）的类是抽象类，必须使用abstract关键字修饰；4、抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以有具体的方法；5、如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类；6、抽象类中的抽象方法只有方法体，没有具体实现；
接口：1、接口使用interface修饰；2、接口不能被实例化；3、一个类只能继承一个类，但是可以实现多个接口；4、接口中方法均为抽象方法；5、接口中不能包含实例域或静态方法（静态方法必须实现，接口中方法是抽象方法，不能实现）
抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。
从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
相同点
- 接口和抽象类都不能实例化
- 都位于继承的顶端，用于被其他实现或继承
- 都包含抽象方法，其子类都必须覆写这些抽象方法
不同点
参数 | 抽象类 | 接口 |
声明 | 抽象类使用abstract关键字声明 | 接口使用interface关键字声明 |
实现 | 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现 | 子类使用implements关键字来实现接口。它需要提供接口中所有声明的方法的实现 |
构造器 | 抽象类可以有构造器 | 接口不能有构造器 |
访问修饰符 | 抽象类中的方法可以是任意访问修饰符 | 接口方法默认修饰符是public。并且不允许定义为 private 或者 protected |
多继承 | 一个类最多只能继承一个抽象类 | 一个类可以实现多个接口 |
字段声明 | 抽象类的字段声明可以是任意的 | 接口的字段默认都是 static 和 final 的 |
备注：Java8中接口中引入默认方法和静态方法，以此来减少抽象类和接口之间的差异。
现在，我们可以为接口提供默认实现的方法了，并且不用强制子类来实现它。
接口和抽象类各有优缺点，在接口和抽象类的选择上，必须遵守这样一个原则：
行为模型应该总是通过接口而不是抽象类定义，所以通常是优先选用接口，尽量少用抽象类。
选择抽象类的时候通常是如下情况：需要定义子类的行为，又要为子类提供通用的功能。
普通类和抽象类有哪些区别？
- 普通类不能包含抽象方法，抽象类可以包含抽象方法。
- 抽象类不能直接实例化，普通类可以直接实例化。
抽象类能使用 final 修饰吗？
不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类
流程控制语句
break ,continue ,return 的区别及作用
- break 跳出总上一层循环，不再执行循环(结束当前的循环体)
- continue 跳出本次循环，继续执行下次循环(结束正在执行的循环 进入下一个循环条件)
- return 程序返回，不再执行下面的代码(结束当前的方法 直接返回)
在java中如何跳出当前的多重嵌套循环
在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的break 语句，即可跳出外层循环。例如：
public static void main(String[] args) {
ok: for (int i = 0; i < 10; i++) {
for (int j = 0; j < 10; j++) {
System.out.println("i=" + i + ",j=" + j);
if (j == 5) {
break ok;
}
}
}
}java面向对象的特征
抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。
封装
封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果属性不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
继承
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。
关于继承如下 3 点请记住：
子类拥有父类非 private 的属性和方法。
子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。（以后介绍）。
多态
所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）抽象类和抽象方法。
其中Java 面向对象编程三大特性：封装 继承 多态
封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。
继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承可以提高代码复用性。继承是多态的前提。
Java语言支持的变量类型
- 类变量：独立于方法之外的变量，用 static 修饰。
- 实例变量：独立于方法之外的变量，不过没有 static 修饰。
- 局部变量：类的方法中的变量。
实例：
public class Variable{
static int allClicks=0; // 类变量
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
