简单java问题 官方说法 java基础 初级第一章

什么是Java编程的关键字

1. 关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。
2. Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。
3. Java语言规定关键字不能作为标识符。目前共有50个Java关键字，其中，"const"和"goto"这两个关键字在Java语言中并没有具体含义。Java语言把它们列为关键字，只是因为"const"和"goto"是其他某些计算机语言的关键字。
   
   

关键字和保留字的区别

正确识别java语言的关键字（keyword）和保留字（reserved word）是十分重要的。Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。

保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。
识别java语言的关键字，不要和其他语言如c/c++的关键字混淆。
标志符包含关键字而关键字里面又包含两个保留字，根据java文档true、false、null不属于关键字但是属于标志符，规定的关键字只有50个包含两个保留字，但是这53个都属于标志符。

1.保留字（reserved words）：是语言已经定义过的字，一些保留字可能没有相对应的语法，考虑到扩展性，为了向后兼容不能再将其作为变量名。const和goto是java的保留字。 所有的关键字都是小写

2.关键字（keywards）：在语言中有特殊的含义成为语法的一部分。

JAVA语法——标识符

标识符：就是给类、接口、方法、变量等起名字的字符序列
组成规则：英文大小写字母、数字字符、$和-(字下美人数骆驼)
注意事项：不能以数字开头、不能是java中的关键字、区分大小写
常见的命名规则(见名知意)
A: 包 全部小写
单级包： 小写 举例：kgc,com
多级包： 小写，并用.隔开 举例：cn.bdqn,pojo.user
B: 类或者接口
一个单词：首字母大写 举例：Student,User
多个单词：每个单词首字母大写 举例：HelloSpring,UserName
C: 方法或者变量
一个单词：首字母小写 举例：name,main
多个单词：从第二个单词开始，每个单词首字母大写 举例：studentAge,showAllNames()
D: 常量 全部大写
一个单词：大写 举例：SESSION
多个单词：大写，并用_隔开 举例：SESSION_DEV_USER

什么是变量？

一、变量
1.在程序运行过程中，随时可能会产生一些临时数据，应用程序将这些数据保存到一些内存单元。这些内存单元叫变量
2.变量包括 变量名 变量类型 变量值
3.变量的作用:
变量可以用来存储 一个 数据，给这个数据起了名字(变量名)方便程序员使用该变量
4.使用变量之前需要先声明，再赋值。
5.如何声明变量：如何赋值：
1）数据类型 变量名；
例:int a;//声明一个int 类型的变量
2）数据类型 变量名1，变量名2，变量名3,…;
例：int a,b,c,d;//声明int类型的变量a,b,c,d
3）给变量赋值：变量名=值；
4）变量的声明和赋值可以写在一起：
数据类型 变量名 = 值;
数据类型 变量名 = 值,变量名 = 值,变量名=值;
5）变量声明了以后一直可以使用么？
全局变量可以，局部变量出了局部失效

常量

常量：在程序执行过程中，其值不发生改变的量。
优点：比较安全
推荐做法：
（1）常量名通常大写
（2）不同字符使用下划线分隔
（3）只能被赋值一次，通常定义时即对其初始化

什么是类？

1.类是一个模板，它描述一类相同属性的对象的行为和状态。
例：建立一个学生类，有年龄，性别，名字等属性，有学习、打游戏等方法。那么这些属性是来描述学生 群体的共同特征和共同行为。
2.类的作用是什么？
类就是用来存放和操作数据的
3.如何使用类
类是一个模板，如果要使用的话，是使用模板产生的某一个对象。每个对象都是唯一的。
Student stu=new Student();//使用new关键字来创建对象

四、程序主入口：main方法
，static public void main(String args[]){}
，public static void main(String args[]){}
，public static void main(String… args){}

五、调用普通方法：
类对象.方法名（参数）；

Abstract 抽象的 理解

Abstract 抽象的 一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现。

abstract关键字可以修改类或方法。abstract类可以扩展（增加子类），但不能直接实例化。abstract方法不在声明它的类中实现，但必须在某个子类中重写。采用 abstract方法的类本来就是抽象类，并且必须声明为abstract。

Java中的名称命名规范：

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

数据类型 （注意float、boolean、char ）String不是基本数据类型

float 默认值是0.0f float f1=253.4f;
double 默认值是0.0d double d1=123.4;
boolean 默认值是false;

Java虚拟机与跨平台原理

什么是跨平台

java的跨平台不是java源程序的跨平台 ，如果是这样，那么所以语言都是跨平台的， java源程序先经过javac编译器编译成二进制的.class字节码文件（java的跨平台指的就是.class字节码文件的跨平台，.class字节码文件是与平台无关的），.class文件再运行在jvm上，java解释器（jvm的一部分）会将其解释成对应平台的机器码执行，所以java所谓的跨平台就是在不同平台上安装了不同的jvm，而在不同平台上生成的.class文件都是一样的，而.class文件再由对应平台的jvm解释成对应平台的机器码执行。 最后解释下机器码和字节码的区别: 一，机器码，完全依附硬件而存在～并且不同硬件由于内嵌指令集不同，即使相同的0 1代码 意思也可能是不同的～换句话说，根本不存在跨平台性～比如～不同型号的CPU,你给他个指令10001101，他们可能会解析为不同的结果～ 二，我们知道JAVA是跨平台的，为什么呢？因为他有一个jvm,不论哪种硬件，只要你装有jvm,那么他就认识这个JAVA字节码～～～～至于底层的机器码，咱不用管，有jvm搞定，他会把字节码再翻译成所在机器认识的机器码～～～

一.Java的跨平台性

1.Java可以跨平台，C和C++不具有跨平台的特性，
2.编写的Java源码，编译后会生成一种 .class 文件，称为字节码文件。Java虚拟机就是负责将字节码文件翻译成特定平台下的机器码然后运行。也就是说，只要在不同平台上安装对应的JVM，就可以运行字节码文件，运行我们编写的Java程序。
3.而这个过程中，我们编写的Java程序没有做任何改变，仅仅是通过JVM这一”中间层“，就能在不同平台上运行，真正实现了”一次编译，到处运行“的目的。
4.运行Java程序必须有JVM的支持，即使将Java程序打包成可执行文件（例如 .exe），仍然需要JVM的支持。
5.注意：跨平台的是Java程序，不是JVM。JVM是用C/C++开发的，是编译后的机器码，不能跨平台，不同平台下需要安装不同版本的JVM。

二.关于JVM的执行效率

1. 解释字节码肯定比全速运行机器码慢很多，但是JVM 有一个选项，可以将使用最频繁的字节码翻译成机器码并保存，这一过程被称为即时编译。这种方式确实很有效，致使微软的 .NET 平台也使用了虚拟机。
2. 现在的及时编译器已经相当出色，甚至成了传统编译器的竞争对手，某些情况下甚至超过了传统编译器，原因是JVM可以监控运行时信息。例如，即时编译器可以监控使用频率高的代码并进行优化，可以消除函数调用（即“内嵌”）。
3. 但是，Java 毕竟有一些C/C++没有的额外的开销，关键应用程序速度较慢。比如Java采用了与平台无关的绘图方式，GUI程序（客户端程序）执行要慢；虚拟机启动也需要时间。
   

深入分析Java的编译原理

前提了解网址

JAVA的编译过程

    JAVA中的编译器和解释器： 　　
    Java中引入了虚拟机的概念，即在机器和编译程序之间加入了一层抽象的虚拟的机器。这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由解释器来将虚拟机代码转换为特定系统的机器码执行。在Java中，这种供虚拟机理解的代码叫做字节码（即扩展名为.class的文件），它不面向任何特定的处理器，只面向虚拟机。每一种平台的解释器是不同的，但是实现的虚拟机是相同的。Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行，这就是上面提到的Java的特点的编译与解释并存的解释。

Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm---->jvm中解释器----->机器可执行的二进制机器码---->程序运行。

采用字节码的好处： 　　Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不专对一种特定的机器，因此，Java程序无须重新编译便可在多种不同的计算机上运行。

Java可以做什么

客户端 银行软件、商场结算软件
浏览器 京东商城、淘宝网、易趣网
移动端 Android APP
高速运算和存储 大数据开发

程序与Java

编写程序的工具就是计算机语言，Java就是多种语言中的一种

Java发展史与体系结构

java 如何换行输出信息？

Java编码规范

Scanner的使用 在程序运行中，如何接收用户键盘输入的值？

自动类型转换规则 强制类型转换规则

数据类型转换包括自动类型转换和强制类型转换

赋值运算符、算术运算符、关系运算符、逻辑运算符

算数运算符

关系运算符

=为赋值运算符，==为等于运算符 关系表达式的结果为布尔值

、<、>=、<= 运算符的优先级别高于==、!=
、<、>=、<=运算符只支持数值类型的数据比较

赋值运算符

逻辑运算符

条件运算符

运算所需变量为三个的运算符叫做三目运算符，只有条件表达式【?:】

运算符优先级 所谓优先级就是在表达式运算中的运算顺序。

单目运算符包括! ++ --，优先级别高
优先级别最低的是赋值运算符
可以通过()控制表达式的运算顺序，()优先级最高
从右向左结合性的只有赋值运算符、三目运算符和单目运算符
算术运算符 >逻辑非运算符【!】、按位取反运算符【~】、自增自减运算符【++， --】、负号运算符【-】、类型转换运算符【(类型)】、指针运算符和取地址运算符【*和&】、长度运算符【sizeof】 关系运算符 > 逻辑运算符

运算所需变量的个数决定几目运算符

一个4、5位数一个个取出来

int num = 6325;int qian = num/1000;int bai = num/100%10;int shi = num/10%100%10;int ge = num%100%10;
System.out.println(qian+","+bai+","+shi+","+ge);

变成5位数 只会影响千位 后面的百十个位不受影响

基本的if选择结构

if选择结构是根据条件判断结果选择不同的处理 结果必须是布尔值

使用复杂条件的if选择结构

==使用逻辑运算符 复杂条件使用括号提高可读性 ==

使用if-else选择结构

为什么使用多重if选择结构

== 单个if选择结构无法完成 多个if选择结构麻烦且效率低 ==
使用多重if选择语句处理问题时需要注意顺序

嵌套if选择结构

嵌套if控制语句可以通过外层语句和内层语句的协作，增强程序的灵活性

为什么使用switch选择结构

如果使用多重if选择结构完成，但是从代码的结构上看，显得代码冗余，结构复杂，有多次的等值判断。
为了解决上述问题，我们引出switch的选择结构
注意：
①常量名不能重复
②case后面的常量不是必须要按照某种顺序的，switch后面的值会去找和自己匹配的常量值，然后执行对应的代码块，如果没有找到，则执行default中的值
③break结束当前的执行内容，在case后面执行，如果没有break代码会继续向下执行，一直到遇到break或整个switch语句运行完
④default在最后的时候，break是可以省略的（不推荐），在其他位置的时候，不能省略，否则会一直向下执行直到遇到break为止
default块和case块的先后顺序可以变动,不会影响程序执行的结果.通常,default块放在末尾,也可以省略.
每个case后的代码块可以有多个语句,即可以有一组语句,而且不需要用"{}“括起来.
case和default后都有一个冒号,不能漏写,否则编译不通过.对于每个case的结尾,都要想一想是否需要从这里跳出整个switch选择结构.如果需要,一定不要忘记写"break;”.
　　
　　在case后面的代码中,break语句是可以省略的,还可以让多个case执行同一语句.
　　
大家会发现多重if选择结构和switch选择结构很相似,它们都是用来处理多分支条件的结构,但是switch选择结构只能用于等值条件判断的情况


表达式 即条件可以是

产生随机数（0~9）的方法如下

java生成指定范围的随机数

生成区间 [64,128] 中随机值的代码为：
rand.nextInt(65)+ 64;
取值可能性的数量是如何计算出来的呢？当然是 最大取值-最小取值+1 通用公式如下：

Random rand = new Random();
int randNumber =rand.nextInt(MAX - MIN + 1) + MIN; // randNumber 将被赋值为一个 MIN 和 MAX 范围内的随机数

• 生成0-n之内的数字 [0,n] * int i1 = random.nextInt() * (n-0+1);
• 生成 [m,n] 的数字 [m,n] * int i1 = random.nextInt() * (n-m+1)+m;

•                             [0, 100)。            rand.nextInt(100);                        
  

• 生成一个50位的随机a~z字符串。[a,z]

public void test4(){
    String result = "";
    char chValue ;
    int inValue;
    for(int i = 0 ; i < 50; i++){
        inValue = (int) (Math.random()*(122-97+1)+97);
        chValue = (char) inValue;
        result += chValue + ",";
    }
    System.out.println("运行结果：" + result);
}

字母小写a-z：97-122； 字母大写A-Z：65-90； 数字到字母char接收转化

变大小写把char弄成String这种复杂 可直接用Character

java中next与nextLine的用法

nextLine（）方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。
next（）会自动消去有效字符前的空格，只返回输入的字符，不能得到带空格的字符串。
（简单点说，next我只要字，nextLine我啥都要）
next（）在输入有效字符之后，将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。
nextLine（）方法的结束符只是Enter键

3种循环结构

while循环结构 先判断，后执行。 循环次数不确定

while循环语句也称条件判断语句，他的循环方式为利用一个条件来控制是否要反复执行这个语句。
语法：while(条件表达式){//要执行循环操作的代码块} 。循环条件是一个表达式，它的值为boolean类型，

声明并初始化循环变量
判断循环条件是否满足，如果满足则执行循环操作，否则退出循环
执行完循环操作后，再次判断循环条件，决定继续执行循环或者退出循环

do-while循环结构 先执行，后判断 循环次数不确定

Java中的for循环 循环次数确定 先判断，再执行

3种形式

//第一种是普通的for循环遍历、
for (int i = 0; i < list.size(); i++) {
   System.out.print(list.get(i) + ",");
}
//第二种是使用迭代器进行遍历
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
   System.out.print(iterator.next() + ",");
}
//第三种我们一般称之为增强for循环（for each）
for (Integer i : list) {
   System.out.print(i + ",");
}

== 增强for循环有两个好处： 1.写起来简单 2.遍历集合、容器简单==
通过反编译，我们看到，其实JAVA中的增强for循环底层是通过迭代器模式来实现的。下面删除元素采坑点分析
既然增强for循环通过迭代器实现，那么必然有迭代器的特性。
Java中有fail-fast机制。在使用迭代器遍历元素的时候，在对集合进行删除的时候一定要注意，使用不当有可能发生ConcurrentModificationException，这是一种运行时异常，编译期并不会发生。只有在程序真正运行时才会爆发。

Iterator是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出java.util.ConcurrentModificationException异常。
所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。
但你可以使用 Iterator 本身的方法 remove() 来删除对象，Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。

使用for循环，输出加法表

使用while、do…while、for循环计算100以内的奇偶数之和

参考地址

JAVA之二重循环

break直接跳出当前层次的循环。
return 跳出循环体所在的方法，相当于结束该方法;
continue 结束本次循环，进行下次循环;

二重循环实现乘法表、倒三角

MySQL 自增长主键 在删除数据后依然接着删除的数据增长解决

如题，比如有主键为1,2,3的三条数据，删除2,3两条数据后再新增数据，主键是从4开始的。

原因是主键是唯一的，绝对不能出现重复。比如有100条数据，主键为1到100，删除了主键为50的数据之后，还剩99条数据，这个时候再新增数据，主键是要从101开始，而不是第100条数据的100，不然会重复，有两个主键为100的数据。
不过可以手动修改。
1，删除原有主键：

ALTER TABLE `table_name` DROP `id`;

2，添加新主键字段：

ALTER TABLE `table_name` ADD `id` int NOT NULL FIRST;

3，设置新主键：

ALTER TABLE `table_name` MODIFY COLUMN `id` int NOT NULL AUTO_INCREMENT,ADD PRIMARY KEY(id);

点击查看更多思路

冒泡排序

假如有N个元素，最好的情况我们仅仅需要N-1次比较和交换，最坏的情况下需要N（N-1）/2次比较和交换才能完成。

Java:List,Map,Set底层实现

参考二
参考三

为什么需要程序调试什么是程序调试

编写程序过程中有时出现错误，但不好发现和定位错误，有没有好的方法呢？
通过代码阅读或者加输出语句查找程序错误
当程序结构越来越复杂时，需要专门的技术来发现和定位错误，就是“程序调试”


双重循环中,外层循环变量与内层循环变量的关系是什么?
答：外层循环每执行一次，内层循环要执行一圈
1.continue再循环中的作用
1）在continue分支判断执行时，跳出本次循环，执行下个循环
1.break再循环中的作用
1）在break分支判断执行时，跳出（结束）循环

数组及其基本要素

数组是一个变量，存储相同数据类型的一组数据
Java中，数组变量是引用类型的变量，同时因为Java是典型的静态语言，因此它的数组也是静态的，所以想要使用就必须先初始化（为数组对象的元素分配空间）。

数组基本要素： 标识符 、 数组元素 、 元素下标：从0开始 、 元素类型



使用数组四步走

声明数组: 告诉计算机数据类型是什么

分配空间: 告诉计算机分配几个连续的空间

数组赋值

数组与内存 数组的初始化方式及其内存分配

静态初始化：初始化时由程序员显式指定每个数组元素的初始值，由系统决定数组长度，如：

1 //只是指定初始值，并没有指定数组的长度，但是系统为自动决定该数组的长度为4
2 String[] computers = {"Dell", "Lenovo", "Apple", "Acer"};　　//①
3 //只是指定初始值，并没有指定数组的长度，但是系统为自动决定该数组的长度为3
4 String[] names = new String[]{"多啦A梦", "大雄", "静香"};　　//②

动态初始化：初始化时由程序员显示的指定数组的长度，由系统为数据每个元素分配初始值，如

1 //只是指定了数组的长度，并没有显示的为数组指定初始值，但是系统会默认给数组数组元素分配初始值为null
2 String[] cars = new String[4];　　//③

静态初始化方式，程序员虽然没有指定数组长度，但是系统已经自动帮我们给分配了，而动态初始化方式，程序员虽然没有显示的指定初始化值，但是因为Java数组是引用类型的变量，所以系统也为每个元素分配了初始化值null，当然不同类型的初始化值也是不一样的，假设是基本类型int类型，那么为系统分配的初始化值也是对应的默认值0。

填充替换数组元素2种方法

数组越界异常

如果指定的索引位置大于或等于要进行填充的数组的长度，则会报出ArrayIndexOutOfBoundsException（数组越界异常）异常。
还有常见错误有：1. 编译出错，没有写明数组的大小、2.编译出错，数组越界、
3.编译出错，创建数组并赋值的方式必须在一条语句中完成

对数组进行排序

通过Arrays类的静态sort()方法可以实现对数组的排序。sort方法提供了多种重载形式，可对任意类型的数组进行升序排序。 Arrays.sort(object);

复制数组

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。
copyOf()方法是复制数组至指定长度。copyOfRange()方法是将指定数组的指定长度复制到一个新数组中。
1、copyOf()方法
该方法提供了多种重载形式，用于满足不同类型数组的复制。
语法如下：copyOf(arr,int newlength)

2、copyOfRange()方法
该方法同样提供了多种重载形式。 语法如下：copyOfRange(arr, int from, int to);

数组查询

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组 ，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。
1、binarySearch(Object [ ],Object key)

上面的代码中变量index的值是元素8在数组arr中索引在0~1内的索引位置。由于在指定的范围内并不存在元素8，index的值是“-”（插入点）。如果对数组进行排序，元素8应该在25的前面，因此插入点应是元素25的索引值2，所以index的值是-2。
如果数组中的所有元素都小于指定的键，则为arr.length。

必须在进行此调用之前对数组进行排序（通过sort()方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定索引值的元素，则无法保证找到的是哪一个。

2、binarySearch(Object [ ],int fromIndex,int toIndex,Object key) 该方法在指定的范围内检索某一元素。

在使用此方法之前同样对数组进行排序，来获取准确的索引值。如果要搜索的元素key在指定的范围内，则返回搜索键的索引；否则返回-1或“-”（插入点）。如果范围中的所有元素都小于指定的键，则为toIndex。
如果指定的范围大于或等于数组的长度，则会报出ArrayIndexOutOfBoundsException异常。

Java数组的5种基本操作

1 声明数组
2 获取数组的长度（.length）
3 打印数组（Arrays.toString()）
4 数组元素重排序（Arrays.sort()）
5 判断数组中是否包含某个值

掌握数组常用操作

获取最大 、最小值 、 数字排序 、 插入数字

使用数组有哪些步骤？

三个过程分别是.声明,创建和初始化

二维数组

二维数组其实是一维数组的嵌套（每一行看做一个内层的一维数组）
两种初始化形式 ： 格式1动态初始化、格式2: 静态初始化

使用java.util.Arrays类

二维数组定义、定义并赋值