目录
1.java中变量有哪些
public class Jichu {
public static void main(String[] args) {
// 变量：类变量，实例变量，局部变量。
// 实现键盘输入三位数，输出个位十位百位；
Scanner sc= new Scanner(System.in);
System.out.println("请输入一个三位数：");
int number = sc.nextInt();
int a = number%10;
int b = number/10%10;
int c = number/10/10%10;
System.out.println(a);
System.out.println(b);
System.out.println(c);
2.常用数据类型
整型： byte，short，int，long。
字符型：char。
字符串：String。
布尔型：boolean。
浮点型：float,double。
// 数据之间的转换
int a = 10;
int b = 97;
byte g= 127; //byte可表示的范围:-128--127;
float f = 5.2f;
long l = 100l;
char c = 'a';
String d = "bcd";
double e = 10.3;
int sum = a + b;//30
boolean num = a==b;
boolean numb = b==c;
System.out.println(num);
System.out.println(numb);
// 隐式转换：byte-short-int-long-float-double
小转大，char 型数据参与运算用ASCII码；a=97；A=65；
int z;
long y;
double x;
z=c+b;//char+int
y=a+l;//int+long
x=l+e;//long+double
System.out.println("隐式转换"+y);
System.out.println("隐式转换"+z);
System.out.println("隐式转换"+x);
// 强制转换（大转小）
double abc = (int) b + e;
int k=(int)e;
System.out.println("强制转换结果为：" + k);
System.out.println("强制转换结果为：" + abc);
System.out.println("a" + "+" + "b" + "=" + sum);3.常用运算符
// 引用运算符：String 引号；
// 算数运算符 +,-,*,/,%
int a, b, d,e,f;
a = 10;
b = 15;
double c;
c = a + b;//25.0
d = b - a;//5
e=b/a;//商1余5
f=b%a;//5
System.out.println(c);
System.out.println(d);
System.out.println(e);
System.out.println(f);
// 逻辑运算符 &(逻辑与) |(逻辑或) ^(逻辑异或) !(逻辑非)
int a = 10;
int b = 10;
int c = 20;
boolean d =a>b;//false
boolean e =a==b;//true
boolean f =a<c;//true
System.out.println(d&e);//f
System.out.println(d|e);//t
System.out.println(e&f);//t
// 赋值运算符 =,+=,*=,-=,/=,%=
int a= 10,b;
b=a;
System.out.println(b);//b=10
b+=a; //b=b+a b=20
System.out.println(b);//b=20
b*=a; //b=b*a b=200
System.out.println(b);//b=200
b/=a; //b=b/a b=20
System.out.println(b);//b=20
b%=a; //b=b%a
System.out.println(b);//b=0
// 关系运算符 == != < > <= >=
int a=30,b=20;
if (a==b){
System.out.println("相等");
}
if(a!=b){
System.out.println("不相等");
}
if(a>b){
System.out.println("a更大");
}else if (a<b){
System.out.println("b更大");
}
// 短路运算符 && ||；
int a=10,b=20;
if(a<b&&b>a){
System.out.println("正确");
}else {
System.out.println("错误");
}
if (a<b||b<a)
{
System.out.println("正确");
}else {
System.out.println("错误");
}
// 三目运算符
// 关系表达式?表达式1:表达式2
// 若关系表达式为true,输出表达式1,若false输出表达式2
int a=10,b=20;
1. int max=a<b?a:b;
System.out.println(max);
2. System.out.println(a<b?a:b);4.数组
// 数组
// 动态数组初始化
int[] arry = new int[6];
// 静态数组初始化
int[] arry1 ={1,2,3,4,5,6,7,8,9,10};
// For-Each 循环:
/* 它能在不使用下标的情况下遍历数组
模板：for(变量类型: array){
System.out.println(element);
}
*/
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}
}
// 获取数组
System.out.println(arry1[0]);
System.out.println(arry1[1]);
System.out.println(arry1[2]);
System.out.println(arry1[3]);
for (int i = 0; i < 4; i++) {
System.out.println(arry1[i]);
}
// 数组遍历
for (int i = 0; i < arry1.length; i++) {
System.out.println(arry1[i]);
}5.条件判断语句(if)
if (关系表达式[返回值是boolean类型]){
// 如果关系表达式为true,则执行
}else{
// 如果关系表达式为false,则执行
}6.分支条件选择语句
// switch...case 根据表达式内的条件去分别对应case里的语句后直接输出；
switch(表达式){
case 0:
语句1;
break;
case 1:
语句2;
break;
case 2:
语句3;
break;
default:
语句n;
break;
} 7.循环语句
// for 循环
// 格式:
for ("定义变量初始化","循环条件","变量循环方式"){
"循环体";
}
// while 循环
// 格式:
while (循环条件){
循环体
}
// do-while 循环
// 格式:
do{
循环体
}while (循环条件);
8.注释语句
单行注释: //
多行注释: /*...*/
文档注释: /**...*/9.异常处理语句
一般以Exception为后缀
10.number & Math 类的方法
1. xxxValue() : 将 Number 对象转换为xxx数据类型的值并返回。
2. compareTo() : 将number对象与参数比较。
3. equals() : 判断number对象是否与参数相等。
4. valueOf() : 返回一个 Number 对象指定的内置数据类型
5. toString() : 以字符串形式返回值。
6. parseInt() : 将字符串解析为int类型。
7. abs() : 返回参数的绝对值。
8. ceil() : 返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
9. floor() : 返回小于等于（<=）给定参数的最大整数 。
10. rint() : 返回与参数最接近的整数。返回类型为double。
11. round() : 它表示四舍五入，算法为 Math.floor(x + 0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5)的结果为 - 11。
12. min() : 返回两个参数中的最小值。
13. max() : 返回两个参数中的最大值。
14. exp() : 返回自然数底数e的参数次方。
15. log() : 返回参数的自然数底数的对数值。
16. pow() : 返回第一个参数的第二个参数次方。
17. sqrt() : 求参数的算术平方根。
18. sin() : 求指定double类型参数的正弦值。
19. cos() : 求指定double类型参数的余弦值。
20. tan() : 求指定double类型参数的正切值。
21. asin() : 求指定double类型参数的反正弦值。
22. acos() : 求指定double类型参数的反余弦值。
23. atan() : 求指定double类型参数的反正切值。
24. atan2() : 将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。
25. toDegrees(): 将参数转化为角度。
26. toRadians(): 将角度转换为弧度。
27. random() : 返回一个随机数。11.转义字符
// 前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。
\t 在文中该处插入一个tab键.
\b 在文中该处插入一个后退键.
\n 在文中该处换行.
\r 在文中该处插入回车.
\f 在文中该处插入换页符.
\' 在文中该处插入单引号.
\" 在文中该处插入双引号.
\\ 在文中该处插入反斜杠.
12.面向对象
// 一.对象和类的理解
类 ：是来描述一个事物的设计图
对象 ：是真是存在的案列
JavaBean类（自定义类）：自定义用来描述一类事物的类
main方法的类（测试类） ：在测试类中创建（定义类）javabean类的对象并对其对象属性进行调用
// 二.类
1.Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码的文件名
2.JavaBean类的成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值；一般只定义不赋值
// 三.对象成员变量的默认值规则
1.基本类型
byte、short、int、long默认值是0
float、double默认值是0.0
boolean默认值是false
2.引用类型
类、接口、数字、String默认值是null
// 四.对象的封装
封装、继承和多态是面向对象的三大特征
封装：即将对象中的所有数据打包，并提供数据对应得行为
1.private修饰的类或变量只能在所在的类中调用，但可以通过set()和get()调用到其他类中。
2.set()是给private修饰的变量赋值，get()是向外return出private变量的值
// 五.对象的应用
1.在测试类中创建（new）一个新的对象
空参：类名 对象名 = new 类名（）；
有参：类名 对象名 = new 类名（数据类型 实参名，.........）；
2.在JavaBean类中定义对象属性和构造方法(ATL+INSERT)
①构造方法
空参构造：无参数
有参构造：将成员变量全部传入到方法中，再用this将数据保存到成员变量
②创建set（）和get（）方法在JavaBean类和测试类中进行数据交互
3.在测试类中通过set（）方法给对象属性进行赋值，用get（）方法调用对象属性的值
4.创建toString方法，可以直接调用用来输出返回值。
// 六.this关键字
1.成员变量
在public“类”中定义的变量称为成员变量，即作用域为该变量的public类中全部可以调用，成员变量有默认初始化值;
存储在堆内存中，随着对象的消失而消失.
2.局部变量
在public类的“方法”中定义的变量称为局部局部变量，作用域仅在该方法中，程序运行完该方法就会销毁方法中定义的变量内存所占用的空间;
局部变量没有默认初始化值，存储在栈内存中，随着方法运行结束而消失.
3.就近原则
如果成员变量和局部变量重名，在调用变量时，Java会选择离调用语句最近的变量.
4.局部变量中的this.变量
this.变量 是在局部变量中利用this指向该public类中的成员变量地址.
作用：区分同名成员变量和局部变量.
例如:
public states main（[String arg[]]）{
private int a;//成员变量
public int This(int a){ //这里的a为局部变量
this.a = a //此时通过改变形参a的值从而改变private int a的值
}
}
// 七.创建标准的JavaBean类
1.类名需要见名知意
2.成员变量用private修饰
3.提供至少两个构造方法
①无参构造方法
②带全部参数的构造方法
4.成员方法
①提供每一个成员对应的set（）和get()
②其他需求的行为13.静态(static)
// 一 . 被static修饰的成员变量叫做静态变量
特点:1.被该类所有对象共享
2.不属于对象,属于类.
3.随着类的加载而加载,优先于对象存在.
调用方式: 可直接"类名."出来.
// 二 . 被static修饰的成员方法叫做静态方式
特点: 1.多用在测试类和工具类中.
2.javabean类中很少调用.
javabean类:描述一类事物的类.
测试类:检测其他的类是否书写正确,带有main方法的类,是程序的主入口.
工具类（util）:不是用来描述事物的，而是帮我们做一些事情的类.
静态方法中只能访问静态变量；
非静态方法可以访问所有变量；
静态方法中没有this、super关键字
14.面向对象的三个特征
1.封装 2.继承 3.多态
// 封装
封装是实现面向对象程序设计的第一步，封装就是将数据或函数等集合在一个个的单元中（我们称之为类）。被封装的对象通常被称为抽象数据类型。
// 封装的意义：
封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。
// 封装的作用
1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节；
常见的封装层：Utils层(工具类)，Service层（业务设计）；
Utils层是用来编写(封装)工具类，方便其他层调用；
Service层是建立在DAO层之上的，建立了DAO层后才可以建立Service层，而Service层又是在Controller层(servlet层)之下的，因而Service层应该既调用DAO层的接口，它刚好处于一个中间层的位置。每个模型都有一个Service接口，每个接口分别封装各自的业务处理方法。
// 类成员的访问修饰符：
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
private √ × × ×
// 继承
继承主要实现重用代码，节省开发时间.
如果多个类的某个部分的功能相同，那么可以抽象出一个类出来，把他们的相同部分都放到父类里，让他们都继承这个类.
格式:public class 子类 extends 父类{}
java支持多层继承
子类 ———》 父类A ———》父类B
（直接父类） （间接父类）
若子类中没有构造方法，则默认具有一个空参构造--》public Zi(){}
1.子类中无法继承父类的构造方法；
2.子类能继承父类public和private的成员变量，
private无法直接使用，需要使用set get才能调用；
3.子类能继承父类public的成员方法，private的无法继承；
子类中直接调用父类：super.父类名
// 多态
1、“一个接口，多种方法”
同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
多态的三个条件:
1. 继承的存在(继承是多态的基础,没有继承就没有多态).
2. 子类重写父类的方法(多态下调用子类重写的方法).
3. 父类引用变量指向子类对象(子类到父类的类型转换).
重载（overload）和重写（override）是实现多态的两种主要方式。
２、实现多态：
接口多态性。
继承多态性。
通过抽象类实现的多态性。
// 方法重写：@Override
1.@Override 写在重写后的方法上，为了效验子类重写时语法是否正确。
2.加上注解后如果Overridde下方有红线，表示语法错误
需要注意：
1.重写方法的名称、形参列表必须与父类中的一致；
2*.子类重写方法时，访问权限（修饰符）必须大于等于父类（空着不写>protected>public）
3*.子类重写父类方法时，返回值类型（父类不能回头调用子类的内容）必须小于等于父类；
4.建议:“重写的方法尽量和父类保持一致”
5.只有被添加到虚方法表中的方法才能被重写!
虚方法:“非private,非static,非final”的才能被写进虚方法中
// 实现
如果多个类处理的目标是一样的，但是处理的方法方式不同，那么就定义一个接口，也就是一个标准，让他们的实现这个接口，各自实现自己具体的处理方法来处理那个目标
// 继承和实现的区别：
1、数量不同：java只支持接口的多继承，不支持“继承”的多继承，继承在java中具有单根性，子类只能继承一个父类。总结就是：单继承，多实现。
2、修饰不同：继承：extends;实现：iimplements
3、属性不同：在接口中只能定义全局变量和无实现的方法。而在继承中可以定义属性方法，变量，常量等。
4、调用不同：当接口被类实现时，在类中一定要实现接口中的抽象方法；而继承想调用哪个方法就调用哪个方法。
15.final类型
把类定义成最终类，无法被继承，或者用于修饰方法，该方法不能被子类重写
重载:方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同
例：class Dog{
public void bark(){
sout("woof");
}
public void bark(int num){
"方法"
sout("woof");
}
}
***区别点 重载方法 重写方法
***参数列表 必须修改 一定不能修改
***返回类型 可以修改 一定不能修改
***异常 可以修改 可以减少或删除，一定不能抛出新的或者更广的异常
***访问 可以修改 一定不能做更严格的限制（可以降低限制）
16.接口与接口的实现
// 接口(interface);
1.一个类通过继承接口的方式,从而来继承接口的抽象方法.
2.除非实现接口的类是抽象类,否则该类要定义接口中的所有方法;
3.接口与类相似点：一个接口可以有多个方法。
// 接口与类的区别：
1.接口不能用于实例化对象。
2.接口没有构造方法（不能与类名/接口名相同）。
3*.接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
4.接口不能包含成员变量，除了 static 和 final 变量。
static int a = 0;(static可以省略不写,但后边变量必须要赋值)
5.接口不是被类继承了，而是要被类实现。
6.**接口支持多继承**。
public interface 子接口 extends 父接口1, 父接口2{}
7.接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 "public" 其他的修饰符都会报错
// 接口的实现：
1.当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
public class （class类名） implements （接口类名）{}
2.类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。
3.一个类可以同时实现多个接口.
4.子接口继承父接口的方法：接口的继承使用extends关键字。
public interface 子类 extends 父类1,父类2{}
5.接口继承可以实现不同的包之间继承17.try catch语句
try {
// 程序代码
} catch (异常类型1 异常的变量名1) {
// 程序代码
} catch (异常类型2 异常的变量名2) {
// 程序代码
} catch (异常类型3 异常的变量名3) {
// 程序代码
}finally{
}18.javaweb简介
大体分为6层:
1.javaBean层(命名要求:"大驼峰,与数据库表名相同"):主要用来创建实体类(要求与数据库字段名相同)以及构造方法(包括setter,getter,空参,实参,toString);
2.Dao层(分为接口和class实现类):
接口 (UserDao):用来定义一种(多种)方法;
实现层(新建UserDaoImpL包,包下新建class类(UserDaoimpl)):主要用来连接数据库,写SQL的crud语句,执行SQL的crud语句及关闭对象;
3.service层(封装及调用):大概与Dao层类似,用来调用Dao层,并创建新的方法给service实现层实现;
4.servlet层(用来与前段jsp或HTMl进行交互):继承HTTPSERVLET的(需求和结果),通过doGet,doPost等方法和页面进行互动
5.Utils层(工具类):用来化繁为简,内容为需要多次调用的类或方法
6.WEB层:用来导入JAR包及写JSP页面.