Java基础入门-详细总结

「爱情、让人受尽委屈。」 2023-01-06 01:42 192阅读 0赞

### Java基础入门知识总结 ###

*  一.java基础
 *   *  1.1 java基础知识
     *  1.2java的基本数据类型
     *  1.3运算符
     *  1.4循环结构
     *  1.5数组
     *  二.面向对象
     *  2.1方法
     *  2.2面向对象
     *  2.3内存管理
     *  2.4继承
     *  2.5向上造型
     *  2.6方法重写
     *  2.7成员变量
     *  2.8接口
     *  2.9多态

# 一.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文件字节码文件（包括方法）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk4MDExNg_size_16_color_FFFFFF_t_70]

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）对一个变量的修改不会影响另一个变量的访问
    
    如下图显示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk4MDExNg_size_16_color_FFFFFF_t_70 1]

## 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）多态的表现形式：重写+继承

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk4MDExNg_size_16_color_FFFFFF_t_70]: /images/20221119/bd0e451aeb98469da7f4b50cb22b2f42.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDk4MDExNg_size_16_color_FFFFFF_t_70 1]: /images/20221119/f9c44ba7960e444aad0031c19625c3da.png