前言
Java的特点
他是企业级的web开发，Java2平台企业版(Java 2 Platform,Enterprise Edition),J2EE是一套全然不同于传统应用开发的技术架构，包含许多组件，主要可简化且规范应用系统的开发与部署，进而提高可移植性、安全与再用价值。
J2EE是什么
- java是面向对象的一种语言；
- java语言是跨平台的记一次编译到处运行，这讲的是java的可移植性【平台指的是操作系统，如苹果系统，windows系统，linux系统】；
- java语言是高性能，就是功能强大，性能很好，这讲的是java的安全性；
- JAVA是怎么做到一次编译到处运行
【java文件编译成 .class 文件之后是运行 在jvm上的，而jvm 是在安装jdk的时候就部署好了的，所以我们只要安装了jdk就能运行java。与操作系统无关】。
java的运行过程
- 编写java源文件(.java文件)；
(经过java编译器即javac.exe编译。编译时会经过字节码校验器进行校验，类名是否正确，变量是否定义规范。校验合格后编译成功) - 输出java字节码文件(.class文件)；
(由java解释执行器即java.exe将字节码文件(.class文件)加载到java虚拟机 JVM) - java虚拟机(JVM).class文件在JVM中执行；
java数据类型
- 整数类型：
byte：8位表示一个字节，也就是有8个0和1组成，他能组成256个标识。什么是256个标识呢？
例以下图：
这个叫做二进制，那么什么是256标识呢，就是8个0和1在那摆在那互相的组合，总共能组合256个标识，所以我们说8位他能继承最大 的数是255，因为他从0开始，0~255。所以8位就是有8个0和1组成，总共组成256个描述，0-255个数值。
short：16位，也就是有16个0和1组成，他能组成65536个标识，0~65535个数值。
int：32位，也就是有32个0和1组成，他能组成4294967296个标识，0~4294967295个数值。
long：64位，也就是有64个0和1组成，他能够标识地球上所有的数值。 - 浮点类型：
float: 32位，32个0和1组成，小数能够精确到6位左右。
double:64为，64个0和1组成，小数能够精确到12位左右。 - 字符类型：
char:16位，他是由ASCLL字符表示的， - 布尔类型：
boolean: 标识只有0和1，他是false true 真和假的意思，用来判断的。 - 布尔类型：
一个字节=8个位
范围计算公式:
-2^字节位数-1 ~ (2^字节位数-1)-1
java关键字
| 关键字 | 含义 |
|---|---|
| abstract | 表明类或者成员方法具有抽象属性 |
| break | 提前跳出一个块 |
| case | 用在switch语句之中，表示其中的一个分支 |
| catch | 用在异常处理中，用来捕捉异常 |
| class | 表示是个类 |
| continue | 回到一个块的开始处 |
| do | 用在do-while循环结构中 |
| else | 用在条件语句中，表明当条件不成立时的分支 |
| enum | 枚举 |
| extends | 表明一个类型是另一个类型的子类型，这里常见的类型有类和接口 |
| final | 用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变 |
| finally | 用于处理异常情况，用来声明一个基本肯定会被执行到的语句块 |
| for | 一种循环结构的引导词 |
| if | 条件语句的引导词 |
| import | 表明要访问指定的类或包 |
| interface | 表示其是个接口 |
| new | 用来创建新实例对象 |
| private | 一种访问控制方式：私用模式 |
| protected | 一种访问控制方式：保护模式 |
| public | 一种访问控制方式：共用模式 |
| static | 表明具有静态属性 |
| switch | 分支语句结构的引导词 |
| synchronized | 表明一段代码需要同步执行 |
| throw | 抛出一个异常 |
| throws | 声明在当前定义的成员方法中所有需要抛出的异常 |
| try | 尝试一个可能抛出异常的程序块 |
| while | 用在循环结构中 |
以上为部分举例 , 可根据实际情况度娘一波。
String字符串
String a = “字符串”; ←定义一个String 类型的变量，它是字符串。
字符串有双引号的特证，有双引号的都是字符串。
它不是基本类型。基本数据类型包括byte、int、char、long、float、double、boolean和short。
java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。
为了提高效率节省空间，我们应该用StringBuffer类。
StringBuffer 和 StringBuilder 有什么区别
StringBuffer是线程安全的可变字符序列。
StringBuilder 是非线程安全的可变字符序列。
- StringBuilder 速度比StringBuffer快。
- StringBuffer什么时候用： 数据量大的时候用。
- StringBuffer是线程安全的 StringBuilder 不是线程安全的。
数组
数组（Array）是一种有序的元素序列。
一维数组
一个大箱子，里面有许多元素如yi[/3]这就是装有三个元素的箱子
public static void yiwei(){
int yi[]= new int[3];
yi[0]= 1;
yi[1]= 2;
yi[2]= 3;
for(int i =0;i<yi.length;i++){
System.out.println(yi[i]+" ");
}
}
二维数组
三行三列 就是一维数组的数组如er[/3][/3]有三个装着三个元素的箱子
public static void erwei(){
int er[][]= new int[3][3];
er[0][0]=1;
er[0][1]=2;
er[0][2]=3;
er[1][0]=4;
er[1][1]=5;
er[1][2]=6;
er[2][0]=7;
er[2][1]=8;
er[2][2]=9;
for(int i =0;i<er.length;i++){
for(int j = 0;j<er[i].length;j++){
System.out.print(er[i][j]+" ");
}
System.out.println(" ");
}
}
三维数组
public static void sanwei(){
int san[][][]=new int[2][2][2];
san[0][0][0]=1;
san[0][0][1]=2;
san[0][1][0]=3;
san[0][1][1]=4;
san[1][0][0]=5;
san[1][0][1]=6;
san[1][1][0]=7;
san[1][1][1]=8;
for(int i = 0;i<san.length;i++){
for (int j = 0 ;j<san[i].length ;j++ ){
for(int w =0;w<san[i][j].length;w++){
System.out.print(san[i][j][w]+" ");
}
}
System.out.println(" ");
}
}
变量的作用域和生命周期
int a = 1;
if (true){ //这个if里面就是作用域，这里面创建的变量只能在这个if里面才能用，其他地方调用会出错说找不到
int b = 3;
}
System.out.println(b);
运算符和流程控制
- 简单运算符
+ - * / %(取模) ++ --
前++ //加了之后在运行 ++a
后++ //执行后才加，要运行两次才能看得出效果 a++
前--
后--
PS：++ -- 是减1或者+1
- 逻辑运算符
&& 与
|| 或
! 非
- 流程控制语句
If (){ //单分支
}
If (){ //双分支
}else {
}
If (){ //多分支
}else if (){
}else if (){
}else {
}
Switch(){
Case 常量1:
语句1;
Break;
Case 常量2:
语句2;
Break;
Default 常量1:
语句1;
}
For循环
Int a[] = {1,2,3,4,5,6,7,8,9};
for(int i = 0;i<a.length;i++){
System.out.println(a[i]);
}
for循环运行流程图
面向对象的三大特征
-
封装: 封装是面向对像编程的核心思想。将对象的属性和行为封装起来。其载体是类。类通常对客户隐藏起实现细节。这就是封装的思想。
例如：用户在使用计算机是，只需要是用手指敲击点评就可以实现一些功能，无需知道计算机内部是怎么工作的，及时知道计算机的工作原理，但在使用计算机的与不完全赖于见算计工作原理的细节。 -
继承: 继承是一种连接类的层次模型，而且允许和鼓励类的重用，他提供了一种明确表述共性的方式。对象的一个新类可以从现有的类中派生而来，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类(子类)，而原始类称为新类的基类(父类，超类)。
PS：用Java只支持单一继承。一个类只能有一个父类。 -
多态: 方法重写和方法重载都是多态的表现形式。
PS：多态是建立在继承的基础之上的。继承的机制允许将某个类看成其子类，也可以看成其超类，根据此本性，就可以将多个类看成同一种类型，在子类覆盖了超类的方法后，当方法被同一种类对象调用时，会根据对象所属类的不同而产生不同的行为，这种现象叫多态。
对象是什么
Test a = new Test();
此处A就是Test的对象，用Test的对象a可以调用Test类里面的任何东西，除了被private定义的变量和方法
给对象引用变量赋值
public class lei{
public String a;
}
public class lei1{
public static void main (String [] args){
Lei l = new lei();
L.a = “赋值”;
}
}
构造方法和概念
public class lei3{
public lei3(){
System.out.println(“这就是构造方法”);
}
}
概念：构造方法(constructor)是一个很特殊的方法，在创建一个对象时调用。
- 在new创建一个对象是自动调用构造方法，构造方法隐含的返回类型是类的本身。
- 程序员如果显示提供构造方法，那么系统不会在默认构造方法，否则系统会默认创建一个空的构造方法。
- 除了构造方法以外，其他任何方法都不能调用构造方法。
注意：方法名要和类名一样，一切无返回值的方法叫构造方法，除了构造方法以外，其他任何方法都不能调用构造方法
This关键字
this 关键字代表自己
this关键字主要有三个应用：
- this调用本类中的属性，也就是类中的成员变量；
- this调用本类中的其他方法；
- this调用本类中的其他构造方法，调用时要放在构造方法的首行。
public Class Student {
String name; //定义一个成员变量name
private void SetName(String name) { //定义一个参数(局部变量)name
this.name=name; //将局部变量的值传递给成员变量
}
}
局部变量
if (true){ //这个if里面就是作用域，这里面创建的变量只能在这个if里面才能用，其他地方调用会出错说找不到
int b = 3; //这个就是局部变量 只能在这个if里面用
}
System.out.println(b);
递归
Java支持递归(recursion)，递归是一个按其自身定义事物的过程。
Java中调用自身的方法称为是递归。
递归最经典的例子就是数字的阶乘。如3的阶乘是321＝6：
ps: 递归中最重要的找准结束条件
public class Test {
public int fact(int n){
int result; //阶乘结果
if (n == 1) {
return 1;
}else {
result = fact(n-1) * n;
}
return result;
}
}
public class TestDemo {
public static void main(String []args){
Test te = new Test();
int factValue = te.fact(3);
System.out.println(factValue);
}
}
关键字final
用final修饰的就是常量，常量的值不能修改。
public class Test {
final int i = 1;
}
public class TestDemo {
public static void main(String []args){
Test t = new Test();
t.i = 3;
}
}
static变量与static方法
用static修饰的变量属于类变量，并不是某个对象，当类被装载器装载的时候所有的静态变量会在实例化变量之前得到初始化。
用static修饰方法时该方法仅可以调其他的静态方法和变量，只能访问静态数据，不能以任何方式引用this和super。
静态方法要访问非静态方法和变量时需要用对象引用，而非静态方法可以直接仿问静态成员。
静态方法要访问非静态方法和变量时需要用对象引用，也就是要new对象后再用对象变量调用。
对象的比较
在java中有两种对象的比较方式，分别是 == 运算符与 equals()方法。这两种方法有着本质的区别。
public class Compare {
public static void main(String []args){
String c1 = new String("abc");
String c2 = new String("abc");
String c3 = c1;
System.out.println(c2 == c3);
System.out.println(c2.equals(c3));
System.out.println(c1 == c3);
}
}
== 比较的是两个对象引用的地址是否相等。而equals()方法比较的是值是否相同。
如果是基本类型,用比较的是值是否相等,基本类型没有equals()方法,只有对象才有equals()方法。
如果是对象,用比较的是地址是否相等,如果用equals()比较,比较的是值是否相等。
抽象类
用abstract修饰的方法，就是抽象方法。用abstract修饰的类就是抽象类，抽象类不能实例化对象。
集成一个抽象类，一定要重写超类(父类)的抽象方法
注意事项：
- 抽象类不能创建实例，但可以创建抽象类的引用(声明一个没有new的类变量)
- 抽象类里可以有抽象方法和非抽象方法，抽象方法在子类必须要重写。
- 有抽象方法的类必须是抽象类
- 抽象方法仅声明，不能实现 原因(抽象方法是没有方法体的，因为他不能有)
- abstract不能以static(静态的)，private(私有的)，final(不可修改的常量)同用
public abstract name { //这个是定义一个抽象类
public abstract fangfa(); //这是一个抽象方法， PS：普通类继承了这个抽象类，就必须重写抽象方法，抽象类可以不用
}
接口
- 接口可以继承多个接口
- 一个普通类可以实现多个接口
- 接口不是类，不能new(实例化)
- 接口中定义的方法默认是abstract修饰的
- 抽象类实现接口可以不重写接口里的方法
- 接口中的方法不能以private,protected修饰
- 接口定义的成员默认都是静态的常量，不可修改
- 当接口里的方法与超类里的方法相同时当前类不必实现接口里的方法
- 接口中的抽象方法，可以不加权限修饰符，可以直接这样写：void fun();
- 接口类类似于类的一种结构，比抽象类更抽象，可以理解为纯抽象类，不能有非抽象的方法。
△接口的作用：实现多重继承。
异常
try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。
ps: 当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。
在以下4种特殊情况下，finally块不会被执行：
- 关闭CPU。
- 程序所在的线程死亡。
- 在finally语句块中发生了异常。
- 在前面的代码中用了System.exit()退出程序。
try-catch-finally 规则[异常处理语句的语法规则]
- 必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。
- 必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
- catch 块与相应的异常类的类型相关。
- 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明 的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块
- 可嵌套 try-catch-finally 结构。
- 在 try-catch-finally 结构中，可重新抛出异常。
- 除了下列情况，总将执行 finally 做为结束：JVM 过早终止(调用 System.exit(int))；在 finally 块中抛出一个未处理的异常；计算机断电、 失火、或遭遇病毒攻击。
try、catch、finally语句块的执行顺序
-
当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；
-
当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；
-
当try捕获到异常，catch语句块里有处理此异常的情况时 → 在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；
Throws抛出异常的规则
-
如果是不可查异常(unchecked exception)，即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。
-
必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误
-
仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出，而不是囫囵吞枣。
-
调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。
关于【JAVA基础总结】介绍完毕了, 感谢观看！
如有不足之处请多多包涵, 给出宝贵建议, 谢谢。
8180
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
