Java基础入门-详细总结

一.java基础

1.1 java基础知识

java是高级计算机编程语言——计算机只能识别0和1；
Java语言编译运行过程（跨平台编程语言）
1）.java源文件，经过编译，生成.class字节码文件【编译期】
2）JVM加载.class并运行.class(0和1)【运行期】
名称解释
JVM:  ——java虚拟机，加载.class文件并运行.class
JRE:  ——java运行环境，除了包含JVM以外还包含了运行java程序所必须的环境
             JRE=JVM+java系统类库
JDK:  ——java开发工具包，除了包含JRE以外还包含了开发java程序所必须的命令工具
             JKD = JRE + 编译，运行等命令工具
运行java程序的最小环境为JRE
开发java程序的最小环境为JDK
Eclipse: IDE（集成开发环境），带图形界面的，功能强大的开发工具【IBM公司】
命名规则：   驼峰命名——变量           帕斯卡命名——类

变量的补充:
1.变量的作用域/范围
从变量的声明开始，到包含它最近的大括号结束

int a = 5; // a的作用域从此开始，一直到main结束
if(a>2){
  int b = 6;
System.out.println(a);
System.out.println(b);
}
System.out.println(a);
System.out.println(b);//编译错误，超出b的作用范围了

2.变量的重名问题：
作用域重叠时，变量不能重名：

1.2java的基本数据类型

    一. java中的八种基本数据类型：byte，short，int，long，float，double，boolean，char
1）int; 整型，4个字节；-21多亿到21多亿
1.1）直接量超范围是溢出（溢出是需要避免的）eg：int a=1000000000，//溢出
1.2）运算超范围是编译错误 eg： int a = 1000000*10000；//编译错误
2）Long；长整型 8个字节；
2.1）长整型直接量需要在数字后加L或l
2.2）整数运算有可能溢出，建议在第一个数字后加L
3）double；浮点型； 8个字节；
  3.1）浮点数直接量默认为double型，表示float 需在数字后加F或f
  3.2）double型和float型数据参与运算时，有可能出现舍入误差（精确场合不能使用）
4）boolean； 布尔型； 1个字节，只能复制为true或false；
5）char；字符型； 2个字节
  5.1）采用Unicode字符集编码，每一个字符都有一个对应的码
  5.2）表面形式是char 本质上是码int  ASCII码（‘a’—97  ‘A’—65   ‘0’—48）
  5.3）字符型直接量必须放在单引号中，只能有一个
  5.4）特殊字符需用过\来转义
二.类型间的转换
1）两种方式
类型从小到大依次为：byte -short-int-long-float-double-char
  1.1）自动类型转换，小类型到大类型；
  1.2）强转类型转换，大类型到小类型
语法：（要转换成为的类型）变量，强转有可能溢出或者丢失精度
2）两点规则：Eg:  byte a1 = 5; byte b1 = 6; byte c1 = (byte)(a1+b1);

1.3运算符

1.3.1算术运算符：

一．算术运算符： + ，- ，* ， / ，% ， ++，--
  1）%： 取模/取余，余数为0即为整除，
  2）++/--；自增1/自减1，可在变量前也可在变量后
   2.1）单独使用时，在前在后都一样；
   2.2）被使用时，在前在后不一样   【a++的值为a】，【++a的值为a+1】
                                   【a--的值为a】，【--a的值为a-1】
int a = 5;int b = a++;
		System.out.println(a);//6
		System.out.println(b);//5
二．关系运算符： 
1）> , < , >= , <=, ==(等于), !=(不等于)
2）关系运算的结果为boolean型，成立为true，反之为false

三．逻辑运算符：
1）&&：短路与（并且）两边都为真为true，见false则false；（&&前面false时短路，后面的不执行）
2）||：短路或（或者）有一边为真则为真，见true则为true；（||前面True时短路，后面的不执行）
3）！：逻辑非（取反）非真为假，非假为真；
4）逻辑运算是建立在关系运算的基础之上的，逻辑运算的结果为boolean型；

1.3.2关系运算符

1）> , < , >= , <=, ==(等于), !=(不等于)
2）关系运算的结果为boolean型，成立为true，反之为false

1.3.3逻辑运算符

1）&&：短路与（并且）两边都为真为true，见false则false；（&&前面false时短路，后面的不执行）
2）||：短路或（或者）有一边为真则为真，见true则为true；（||前面True时短路，后面的不执行）
3）！：逻辑非（取反）非真为假，非假为真；
逻辑运算是建立在关系运算的基础之上的，逻辑运算的结果为boolean型；

1.3.4赋值运算符

1）简单的赋值运算符： =
2）扩展赋值运算符： += ，-=，*=，/=，%=
字符串连接运算符
1）+；
1.1）若两边为数字。则做加法运算
1.2）若两边出现了字符串，则做字符串连接
五．条件/三目运算符：
1）语法：
boolean?数1：数2
2）执行过程：
 2.1）计算boolean的值：
      若为true，则整个表达式的结果为数1
      若为false，则整个表达式的结果为数2

交换两个数：追尾并绕圈
int a = b;b = c ; c = d;//两个数之间的交换

1.4循环结构

任何复杂的程序逻辑都可以通过以下三种结构来实现
1.4.1顺序结构
从上往下逐行执行 ，每句必走
1.4.2分支结构

 1）if(boolean){
语句块
}
2) if----else
3)if----else if ---else 
4）switch  --case:结构：多条路
   优点：效率高，结构清晰
   缺点:整数，相等
int num = 2;
switch(num){
case 1：
System.out.println(111);
case 2：
System.out.println(222);
case 3：
System.out.println(333);
default:
System.out.println(444);
}

1.4.3循环结构

一．循环：反复执行一段相同或相似的代码
二．循环三要素
   1)循环变量的初始化
   2）循环的条件（以循环变量为基础）
   3）循环变量的改变（向着循环的结束变）
 循环变量：在整个循环过程中反复改变的那个数
补充：Math.random() 生成随机数 0.000-0.000000009
Eg：int num = (int)(Math.random()*100+1);
三．循环结构： 
1）while 结构://有可能一次都不执行
   While(boolean){
语句块
}
2）do.while  //至少执行一次
   要素1和要素3相同时，首选do --while
  do{
语句块
}while(boolean)
  2.1)先执行语句块，再判断boolean的值，若为true则
      再执行语句块，再判断boolean的值。。。。。。
      若为false，则循环结束；

3）for 结构： 应用率最高，与次数相关的
   break;//跳出循环，跳出一层循环
   continue;//跳出当前循环，继续执行下面的循环；
     for ( 三要素){
语句块;
} 
4）.嵌套循环
1）循环中套循环，一般多行列的使用。多层控制行，内层控制列
2）循环规则：外层循环走一次，内层循环走所有次
3）建议：嵌套的层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明设计有问题

1.5数组

一．概念
1）是一种数据类型（引用类型）
2）相同数据类型元素的集合
3）数组的定义：
int[] a = new int[5]------//声明整型数组，名为a，包含5个元素，每个元素都是int类型
  【占用20个字节，5个元素，每个元素（int）占用4个字节】
double[] d = new double[10]-------//声明浮点型元素d，包含是个元素，为double型，默认值为0.0
 boolean[] b = new boolean[20]----//声明布尔值数组b，包含20个元素，为boolean，默认值为false
4）数组的初始化：
  int[] arr = new int[3]//0,0,0
int[] arr = {1,4,7};//1,4,7
  Int[] arr = new int[]{1,4,7};//1,4,7
5）数组的使用：使用的是数组中的元素
 5.1）通过（数组名.length）可以获取数组的长度（元素的个数）
 5.2）通过下标/索引来访问数组中的元素，下标从0开始，最大是（.length-1）
      arr[0]--------代表arr中的第一个元素
6）数组的遍历：从头到尾将所有数据走一遍
int[] arr = new int[] {1,5,7};
	for(int i=0;i<arr.length;i++) {   //变量arr数组
	    arr[i]=20;    //给arr中的每个元素都赋值为20
	System.out.println(arr[i]);//20,20,20 输出所有元素的值
	}
 找最大值：
1）假设第一个元素为最大值
int max = arr[0];
2)遍历剩余元素,将剩余元素与max做对比
 for(int i =1;i<arr.length;i++){
If(arr[i]>max)
max = arr[i];
}
7）数组的复制：//数组的长度一旦定义好，就不能更改


 7.1）System.arraycopy(arrb,0,arra,0,5);//arrb数组中0下标复制到a数组中0下标开始，复制5个元素（复制arrb数组）
 7.2）
import java.util.Arrays;//引入Arrays
int[] arra=Arrays.copyOf(b,6)  //a数组中复制目标数组的长度

7.3）数组的扩容
   数组无法扩容本身,建立一个更大的数组扩容
int[] a  = new int{1,2,3,4};
int[] b= Arrays.copyOf(a,6);// {1,2,3,4,0,0}
a = Arrays.copyOf(a,a.length+1); //{1,2,3,4,0}

8)数组的排序：
 8.1）排序方式：冒泡排序，快速排序，插入排序等
 8.2） Arrays.sort(arr)//升序排序
  
for (int  i=arr.length-1;i>=0;i--){//降序排序
System.out.println(arr[i]);
}

9)基本类型数组：  eg：  int[] arr;   double[] arr;
引用类型数组：  
 Student[] stus =new Student[3];
 stus[0] = new Student(“张三”,”25”,’男’);
Eg:
 Student[] stus = new Student[3];
 Stus[0] =new Student(“张三”,”25”,’男’);//引用类型元素需new对象创建对象并调用构造方法

二.面向对象

2.1方法

封装一段特定的业务逻辑功能
1）尽可能独立，一个方法只干一件事
2）方法可以被反复调用多次
3）减少代码重复，有利于代码维护
1）定义：五要素
1）修饰词 返回值类型  方法名（参数列表）{
   方法体
}
2）方法的调用
  无返回值： 方法名（有参传参）
  有返回值：  数据类型 变量 = 方法名（有参传参）
5.return：
1）return 值；结束方法的执行，返回结果给调用方---------用在有返回值的方法中
2）return;     结束方法的执行 -----用在无返回值的方法中
  方法可以有返回值，也可以没有返回值
1）无返回值---返回值类型写成void
2）有返回值 ----返回值类型写成特定数据类型即可
何时有返回值？何时没有返回值？
方法执行完后若还需要用到方法中的某个数据----有返回值（若不需要则没有）

2.2面向对象

 1）面向对象：OO; 面向对象的分析：OOA； 面向对象的设计：OOD；
   面向对象编程：OOP；
2）什么是类？什么是对象？
1）现实生活中存在很多很多的对象（东西），基于对象抽出了类
2）对象：软件中真实存在的单个的个体/东西
3） 类：类型/类别，代表一类个体 ，类是对象的模板，对象是类具体的实例；
         自己造的类------引用类型（new 实例化）
4）类中包含：
1.对象所共有的属性/特征 -------变量  
2.对象所共有的行为/动作 -------方法

方法的签名：(方法名+参数列表)//同一个类中不允许方法名和参数列表同时相同
方法的重载：
1）发生在同一个类中，方法名相同，参数列表不同，方法体体不同
2）重载与返回值类型，参数名称无关，与方法名和参数列表（类型）有关
3）编译器在编译时会根据方法的签名自动绑定调用的方法

构造方法：
1）给成员变量赋初值
2）与类同名，没有返回值类型
3）创建（new）对象自动调用
4）若自己没有定义构造方法，则编译期默认提供一个无参构造方法；若自己定义了，则不再默认提供；
5）构造方法可以重载；

this：//指代对象，哪个对象调用方法它指的就是哪个对象
1）只能在方法中，方法中访问成员变量之前默认都有个this
this的用法
1)this.成员变量名 -------------------访问成员变量
2)this.方法名()------------------调用方法（一般不写）
3)this()--------------调用构造方法
成员变量的局部变量可以同名
   用的时候采用就近原则 ，当成员变量与局部变量重名时，若想访问成员变量，则this不能省略
public class BasisTest {
    int a = 4;//成员变量
    int b = 5;
    int count = 0;
    BasisTest(int a,int b,int count){//局部变量
        this.a = a;
        this.b = b;
        this.count = count;
        count = a+b;
        System.out.println(count);
    }
    //......
 }

2.3内存管理

由JVM来管理的
1）堆：存储new 出来的对象（包括成员变量）
2）栈：局部变量（包括方法的参数）
3）方法区：.class文件字节码文件（包括方法）

null：表示空，没有指向任何对象
若引用值的为null 则该引用不能再进行任何操作
若操作则发生NullPointerException（空指针异常）

2.4继承

作用：代码复用
1)通过：extend 父类 来继承
2)超类/父类:派生类所共有的属性和行为；
3)派生类/子类：派生类所特有的属性和行为；
4)派生类继承超类/父类后，派生类具有：派生类+超类的；
5)一个超类可以有多个派生类，派生类只能有一个超类；
6)继承具有传递性；
Java规定：构造派生类之前必须先构造超类，在派生类的构造方法中，若没有调用超类的构造方法，则默认super()调用超类的无参数构造方法；若调用超类的构造方法，则不再默认提供
super
泛化 ----------就是继承
super: 指代当前对象的超类对象
super 的用法：
1）super.成员变量名 -----------访问超类的成员变量
2）super.方法名 -----------------调用超类的方法
3）super()----------------------------调用超类的构造方法


引用类型变量之间画等号：
1）指向同一对象
2）通过一个引用数据的修改会影响另一个引用对数据的访问

基本类型变量之间画等号：
1）赋值
2）对一个变量的修改不会影响另一个变量的访问

如下图显示：

2.5向上造型

1）超类型的引用指向派生类对象；
2）能点出来什么，看引用的类型
3）能造型成为的数据类型有：超类+所实现的接口
4）强制类型装换，成功的条件只有两种：
 4.1）引用所指向的对象，就是该类型
 4.2）引用所指向 的对象，实现了该接口或继承了该类
5）强转时若不符合如上两个条件，则发生ClasscastException类型转换异常
 建议：强转之前先通过instanceof来判断引用的对象是否是该类型
 Eg：
Animal o = new Tiger();//向上造型     o只能.出Animal类中的

2.6方法重写

1）发生在父子类中，方法名相同，参数列表相同，方法体不同
2）重写方法被调用时，看对象类型（new谁调谁）
3）重写需遵循
 3.1）两同：方法名相同，参数列表相同
 3.2）两小：派生类方法的返回值类型小于或等于超类方法
            1）void 时，必须相同；
            2）基本类型时，必须相同
            3）引用类型时，小于或等于
            派生类方法抛出的异常小于或等于超类方法的
 3.3）一大：派生类方法的访问权限大于或等于超类方法的
4）重写与重载的区别：---------------常见面试题
 1）重写（override）
 1.1）发生在父子类中，方法名相同，参数列表相同，方法体不同
 1.2）运行期绑定，看对象调方法
5）重载（overload）
1.1）发生在一个类中，方法名相同，参数列表不同，方法体不同
1.2）编译期绑定，看参数类型绑定方法
6）package：
1）作用：避免类的命名冲突
2）包名常常是有层次结构的，类的全称：包名.类名
3）同包中的类不能同名，不同包中的类可以同名
  建议：域名反写.项目名称.模块名称.类名（所有字母都小写）
  2）import
  1）同包中的类可以直接访问，不同包中的类不能直接访问，若想访问只有如下两种方式
   1.1）类的全称-------------太繁琐，不建议
   2.1）import   +   类的全称
3）访问修饰符【数据（变量）私有化，行为（方法）公开化】
  1）public 公共的，任何类都可以访问
  2）private: 私有的，本类
  3）protected： 受保护的，本类，派生类，同包类
  4）默认的：什么也不写，本类，同包类
补充说明：
1）类的访问权限只能是public和默认的
2）类的成员访问权限如上四种都可以

3）final:   最终的，不可改变的，单独应用几率低
1）修饰变量：变量不能被改变
2）修饰方法：方法不能被重写
3）修饰类：类不能被继承

2.7成员变量

 1）实例变量：没有static修饰，属于对象，存储在堆中，有几个对象就有几份，通过对象点来访问
  2）静态变量：有static修饰，属于类，存储在方法区中，只有一份，通过类名点来访问

1）静态变量：
 1.1）由static修饰
 1.2）属于类的，存储在方法区中，只有一份
 1.3）常常通过类名点来访问
 1.4）何时用：所有对象所共有的（图片，音频等）

2）静态方法：
2.1）由 static修饰
2.2）属于类的，存储在方法区中，只有一份
2.3）常常通过类名点来访问
2.4）静态方法中没有隐式的this传递，所以静态方法中不能直接访问实例成员
2.5）何时用：方法的操作与对象无关

3）静态块：
3.1）由static修饰
3.2）在类被加载期间自动执行，因为类只能被加载一次，所以静态块只执行一次
3.3）何时用：初始化/加载静态资源
4）static final 常量：应用率高
4.1）必须声明同时初始化
4.2）通过类名点来访问，不能被改变
4.3）建议：常量名所以字母都大写，多个单词之间用_分隔
4.4）编译器在编译时会将常量直接替换为具体的值，效率高
4.5）何时用：数据永远不变，并且经常使用
5）抽象方法： 
5.1）由abstract修饰；
5.2）只有方法的定义，没有具体的实现（连大括号都没有）
6）抽象类：
 6.1）由abstract 修饰；
 6.2）包含抽象方法的类必须是抽象类
 6.3）抽象类不能被实例化
 6.4）抽象类是需要被继承的，派生类（抽象类不能创建对象，不继承没有意义）
6.1.1）重写所有抽象方法-------------变不完整为完整
6.1.2）也声明为抽象类-----------------不常用
6.5）抽象类的意义：
 6.5.1）封装派生类所共有的属性和行为-------------代码复用
 6.5.2）为所有派生类提供统一的类型-----------------向上造型
 6.5.3）可以包含抽象方法，为所有派生类提供统一的入口（能点出来）
派生类的具体实现不同，但入口是一致的
  
 设计规则：
1）将派生类所共有的属性和行为，抽到超类中--------抽共性
2）所有派生类的行为都一样，设计为普通方法
3）所有派生类的行为不一样，设计为抽象方法
4）将部分派生类共有的行为，抽到接口中
5）接口是对继承单根型的实现----------多接口的继承

成员内部类：应用率极低，了解
1）类中套类,外面的称为Outer 外部类，里面的称为Inner内部类
2）内部类通常只服务于外部类，对外不具备可见性
3）内部对象通常是在外部类中创建的
4）内部类中可以直接访问外部类的成员（包括私有的），在内部类中有个隐式的引用
指向了创建它的外部类对象  eg：外部类名.this

匿名内部类：
1）若想创建一个类（派生类）的对象，并且对象只被创建一次，此时该类不必命名，称为匿名内部类
2）内部类有独立的.class吗？--------------（常见面试题）
 答：有

业务功能的实现套路
1）先写行为/方法
1.1）若为派生类所特有的行为，就将方法设计在特定的类中
1.2）若为派生类所共有的行为，就将方法设计在超类中
2）窗口调用：
2.1）定时触发的，在定时器中调用
2.2）事件触发的，在侦听器中调用

2.8接口

设计接口：
1）是一种引用数据类型
2）由interface定义，只能包含常量和抽象方法
  Eg: int COUNT = 6;//默认为public static final int COUNT = 6;
     void test();  //默认为public abstract void test();
3）接口不能被实例化
4）接口是需要被实现/继承的，实现/派生类：必须重写所有抽象方法
5）一个类可以实现多个接口，用逗号分隔，若又继承又实现是，应先继承后实现
6）接口可以继承接口

2.9多态

一．意义
 1）同一类型的引用，在指向不同的对象时，有不同的实现
    ----行为的多态
2）同一个对象，被造型为不同的类型时，有不同的功能

内存管理
一．堆：
1.1）存储所有new出来的对象（包括实例变量）
1.2）垃圾：没有任何引用所指向的对象
垃圾回收期（GC）不定时到内存堆中清扫垃圾，回收过程是透明的（看不到的）
不一定一发现垃圾就立刻回收，通过调用System.gc()可以建立虚拟机尽快调度GC
来回收
1.3）内存泄漏：不再使用内存没有被及时的回收，严重的泄漏会导致系统的崩溃
  建议：不再使用的对象及时将引用设置为null；
1.4）实例变量的生命周期：
  创建对象时存在堆中，对象被回收时一并被回收
二.栈：
2.1）存储：正在调用的方法中的局部变量（包括方法的参数）
2.2）调用对象时会在栈中为该对象分配一块对应的栈帧，栈帧中存储方法中的局部变量
  （包括方法的参数）方法调用结束时，栈帧被清除，局部变量一并被清除
2.3）局部变量的生命周期：
调用方法时存储在栈中，方法调用结束时与栈帧一并被清除
四．方法区：
 3.1）只会加载一次

面向对象的三大特征----------------常见面试题
1.封装：
1）类：封装的是对象的属性和行为
2）方法：封装一段特定的业务逻辑功能实现
3）访问控制修饰符：封装具体的访问权限
2.继承：
1.1）作用：代码复用
1.2）
超类：所有派生类所共有的属性和行为
接口：部分派生类所共有的属性和行为
派生类：派生类所特有的属性和行为
1.3）
 单一继承，多接口实现，传递性

 Object 是所以类的鼻祖（父类）
3.多态：
  1.1）行为的多态：所有抽象方法都是多态的
  对象的多态：所有对象都是多态的
 1.2）向上造型，强制类型转换，instanceof判断
 1.3）多态的表现形式：重写+继承