JavaSE基础知识点整理总结

admin管理员组

文章数量:1544589

目录

• • 一、Java语言概述
  • 二、程序设计基础
  • • 1、标识符
    • 2、关键字
    • 3、常量、变量及作用域
    • 4、数据类型
    • 5、运算符与表达式
    • 6、流程控制结构
    • 7、方发初识
  • 三、数组
  • • 1.数组
    • 2. 一维数组
    • 3. 二维数组
    • 4. 数组总结
    • 5. 数组排序
    • • • (1) 冒泡排序
        • (2)选择排序
    • 6. 数组元素查找
    • • • (1). 顺序查找
        • (2). 二分查找
  • 四、面向对象
  • • 1. 面向对象介绍
    • 2. 类和对象
    • 3. 封装
    • 4. 继承
    • 5. 多态
    • 6. 抽象类与接口
    • 7. Object类
    • 8. 设计模式
  • 五、异常
  • • 1. 概念
    • 2. 系统异常分类
    • 3. Error
    • 4. Exception
    • 5. 自定义异常
  • 六、常用类
  • • 1. 基本类型包装类
    • 2. 字符串类
    • 3. 数字常用类
    • 4. 日期处理类
    • 5. 枚举类型
  • 七、集合、Map
  • • 1. 集合概述*
    • 2. Collection接口和Iterator
    • 3. List
    • 4. Set
    • 5. Collections工具类和Comparable、Comparator比较器
    • 6. Map接口
    • 7. 泛型
  • 八、IO流
  • • 1. 流概述
    • 2. File文件操作
    • 3. 文件流
    • 4. 缓冲流
    • 5. 转换流
    • 6. 打印流
    • 7. 对象流
  • 九、网络编程
  • • 1 . 网络基础简介
    • 2. TCP/IP协议**
    • 3. Socket编程
  • 十、多线程
  • • 1. 进程、线程基本概念
    • 2. 线程使用
    • 3. 线程控制
    • 4. 线程同步
    • 5. Lock
  • 十一、新特性
  • • 1. Lambda表达式
    • 2. 函数式接口**
    • 3. 方法引用和构造器调用
    • 4. Stream API
    • 5. 接口中的默认方法和静态方法
    • 6. 新时间日期API

一、Java语言概述

一. 计算机语言发展史

•	机器语言
•   汇编语言
•	高级语言
•	面向对象语言

二. Java版本发展

1. 版本更新

时间 描述
1991~1995 Sun为了占领智能消费电子产品市场，由james gosling负责该项目，来开发Oak语言
1995 将Oak改名为Java
1996 发布JDK1.0
1997 发布JDK1.1
1998 发布JDK1.2，将该版本命名为J2SDK,将Java更名为Java 2
1999 将Java分为三大块:J2SE(Java标准版)、J2EE（Java企业版）、J2ME(Java微型版本)
2000 发布J2SE1.3
2002 发布J2SE1.4
2004 此时不再叫J2SE1.5,叫5.0
2005 2005 Java 10周年，将J2SE改为 Java SE、将J2EE改为 Java EE、将J2ME改为 Java ME
2006 发布 Java SE 6
2011 Oracle 发布 Java SE 7
2014 Oracle 发布 Java SE 8
2017 Oracle 发布 Java SE 9

2. Java三大体系

Java SE

Java SE(JavaPlatform,Standard Edition)。Java SE以前称为J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的Java应用程序。Java SE 包含了支持Java
Web服务开发的类，并为Java EE提供基础。

Java EE

Java EE(Java Platform,Enterprise
Edition)。企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端Java应用程序。Java EE是在Java
SE的基础上构建的,它提供Web 服务、组件模型、管理和通信API,可以用来实现企业级的面向服务体系结构和Web 2.0应用程序。 Java
EE既是一个框架又是一种规范,说它是框架是因为它包含了很多我们开发时用到的组件,例如:Servlet,EJB,JSP,JSTL等。说它是规范又如我们开发web应用常会用到的一些规范模式,Java
EE提供了很多规范的接口却不实现,将这些接口的具体实现细节转移到厂商身上,这样各家厂商推出的Java
EE产品虽然名称实现不同,但展现给外部使用的却是统一规范的接口。

Java ME

Java ME(Java Platform,Micro Edition)。Java
ME为在移动设备和嵌入式设备(比如手机、PDA、电视机顶盒和打印机)上运行的应用程序提供一个健壮且灵活的环境。Java
ME包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于Java
ME规范的应用程序只需编写一次,就可以用于许多设备,而且可以利用每个设备的本机功能。

如图所示

3. Java特性

语言特点

简单易学、面向对象 、平台无关性 

4. Java环境搭建

4.1 环境配置

安装JDK

JDK是整个Java开发的核心，它包含了Java的运行环境(JVM+Java系统类库)和JAVA工具。 

       从官网下载JDK，根据不同系统选择需要的版本。 官网下载地址如下：http://www.oracle/technetwork/java/javase/downloads，下载后直接点击下一步安装即可。
配置环境变量(以windows系统为例)

第一步：
配置JAVA_HOME环境变量右击我的电脑–>点击属性–>左侧的高级系统设置–>点击右下方的环境变量–>点击新建或者编辑系统变量中的JAVA_HOME–>输入JDK的安装目录

第二步：配置Path环境变量右击我的电脑–>点击属性–>左侧的高级系统设置–>点击右下方的环境变量–>双击系统变量中Path属性–>添加%JAVA_HOME%/bin值至尾部 【注意】： “;”来分隔

第三步：配置CLASSPATH环境变量右击我的电脑–>点击属性–>左侧的高级系统设置–>点击右下方的环境变量–>双击系统变量中classpath属性或新建classpath–>添加%JAVA_HOME%/lib值至尾部

【注意】： “.”添加至最前边，并用”;”与后边的隔开

环境变量简介

(1) JAVA_HOME:指定JDK的安装路径，作为全局变量用作后面配置的变量。 
(2) Path:windows系统根据Path环境变量来查找命令。Path环境的值是一系列的路径,如果能通过Path找到这个命令,则该命令是可执行。否则报“XXX命令不是内部或外部命令,也不是可运行的执行程序或批处理文件”。 
 %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin; 
(3) CLASSPATH:指定了运行Java程序时,查找Java程序文件的路径。 
.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;

验证环境变量

按键win+r->输入cmd->进入window命令行界面->输入javac -version->验证版本是否正确。

【注意】：设置环境后要新打开cmd窗口才能生效

按键win+r->输入cmd->进入window命令行界面->输入java -version验证版本和输出是否正确。

4.2 Eclipse安装使用

• 下载和安装

下载地址：官网下载！ 

安装：绿色版免安装
•	基本使用
•	使用Eclipse创建一个HelloWorld工程，并实现打印 “HelloWorld”到控制台

5. Java编码规范

•	严格区分大小写
•	源文件以”.java”为后缀，基本组成单元为class
•	一个Java源文件只能有一个public类，其它非public不限。当存在public类时，源文件名称必须与该类同名，区分大小写。
•	程序主入口为main方法，标准格式为：public static void main(String[] args){}
•	类内部的方法代码以语句为最小单位，每个语句以”;”为分号结束

二、程序设计基础

一、介绍

本章节主要学习程序基础，主要涉及的知识点分为三大块：变量、流程控制、方法。

那么在开始本章内容之前，我们先思考几个问题： 
1. 我们经常看到一个项目成千上万行代码，这些代码都是形成的呢？ 
2. 一条语句又是怎么形成的呢？ 
3. 如果在项目中某一段功能代码需要被重复使用几遍，怎么办？我们就一遍遍地写么？ 
【答案】：
这些成千上万行的代码都是由最简单的一个个语句按照某种流程堆积而成的; 
一条语句一般由关键字、变量和运算符等组成。 
Java中方法可以解决代码复用问题。

1、标识符

1.标识符

1.1释义 
   标识符就是用于给程序中的变量、类、方法命名的符号。标识符可以有编程人员自由定义，但需要遵循一定的命名规则。

1.2命名规则 
	可以由字母、数字、下划线（_）、美元符号（$）组成。
	必须以字母、下划线或美元符号开头，不能以数字开头。
    不能指定为关键字。
    长度没有限制，但定义时一般以见名知义为原则。
	使用驼峰命名，类名首名字均大写，常量全部字母大写；方法名、属性名的单词首字母小写中间的单词首字母大写。

2、关键字

2.关键字

2.1释义 

Java语言中用以特殊用途而预占用的单词或标识符称之为关键字，Java中的关键字均为小写。 

2.2关键字

除了上面表格中，goto和const为Java语言中的两个保留字。保留字是指预留的还未被使用的关键字，但可能在将来的版本中使用。

3、常量、变量及作用域

常量

常量也可称为字面值，即字面显示的值，其本身不会发生变化。 

【样例】

数值型 1234 , 3.14 
字符常量 'c' 
逻辑常量值 true , false 
字符串常量 "Hello" 

• 一种final修饰下的变量也称为常量。 
  
  【格式】 final 数据类型 常量名称[=值] 
  

【常量与变量区别】

常量在程序运行过程中其值不能改变。变量是用于存储可变数据的容器，存储一定格式的可变数据。

命名规范不一样。默认常量为全大写，而变量为驼峰。

修饰符不同。一般常量都会用final修饰。变量不会。而且，为了节省内存，常量都会同时使用static修饰。

变量

变量是程序中最基本的存储单元，由作用域、变量类型、变量名组成。

1.1变量的声明

Java是强声明式语言，每个变量在使用前均要先声明。 

【声明格式】数据类型 变量名称[=值]; 
【代码示例一】 int age; //只声明 
【代码示例二】 int age = 18; //直接初始化

1.2变量分类

变量分为局部变量、成员变量、类变量。

1.2.1局部变量 (本地变量)

方法的形式参数以及在方法中定义的变量。
【格式】 (type name = value) 
【作用范围】 
     形参:在方法体中任何位置都可以访问。 
     方法中定义变量:从定义处开始，直到所在代码块结束。 
【生命周期】 
	 出生:运行到创建变量语句时。 
	 死亡:超过其作用范围。 

1.2.2成员变量 (实例变量，属性)

成员变量就是类中的属性。当new对象的时候，每个对象都有一份属性。一个对象中的属性就是成员变量。

【格式】 (访问修饰符 type name = value) 

【作用范围】 在类内部，任何地方都可以访问成员变量。 

【生命周期】 
     出生:new对象的时候，开辟内存空间。 
     死亡:堆内存地址没有引用，变成垃圾，被垃圾回收器回收后。 

1.2.3类变量 (静态属性)

被static修饰的属性。

【格式】 (访问修饰符 static type name = value) 

【作用范围】 在类变量定义之后。 

【生命周期】 
    出生:类加载时，类变量就分配内存空间。 
    死亡:JVM退出。

4、数据类型

1.释义

数据类型是为了把数据分成所需内存大小不同的数据，编程的时候需要用大的数    据才申请大内存，这样可以充分利用内存。 
Java语言是一种强类型语言，要求所有变量先声明后使用。目的就是为了保证变量或者表达式在编译时就能够确定其类型，
并为其分配相应的内存。

2.分类

2.1整型

     2.1.1 Java整型

byte/short/int/long

     2.1.2整型取值范围

Java语言整数型默认为int类型,如果要声明成long类型在变量值后加入L,如:long l = 123L

类型	占用存储空间字节数	数值范围
byte	1	-128~127
short	2	-2的15次方2的15次方-1（-3276832767）
int	4	-2的31次方~2的31次方-1
long	8	-2的63次方~2的63次方-1

     2.1.3 Java整型常量的三种表示方法

十进制：如123=1*100+2*10+3*1=123 
八进制，八进制0开头：如：013=1*8+3*1=11 
十六进制，十六进制0x开头：如：0x23=2*16+3*1=35 

【进制转换】

10进制到二进制 

示例：求十进制数10的二进制
     6/2=3 余 0
     3/2=1 余 1
     1/2=0 余 1
     将余数逆序输出就是6的二进制表示：110，位数不够补零

二进制到十进制 

示例：求二进制110的十进制

规则：取出最后一位，从2的0次方开始乘，将得到的结果相加即可 

     0*2的0次方=0
     1*2的1次方=2
     1*2的2次方=4
     110的十进制为：0+2+4=6

八进制与二进制、十进制转换类同

2.2浮点型

2.2.1 Java浮点型

float/double

2.2.2两种表示形式

十进制形式：例如：123.456 0.314 
科学计数法：例如：1.23456E2 3.14E-1

2.2.3 Java浮点型取值范围

     浮点声明默认是double类型,若要是float,请在尾部添加f或是F。如:float myFloat=1.23

类型	占用存储空间字节数	数值范围
float	4	-3.4E38 ~ 3.4E38
double	8	-1.7E308~ 1.7E308

2.3布尔型

适用于逻辑运算，用于程序流程控制
只允许取值为true,false，不可以任何其它形式代替

[示例]
     boolean real=true; //正确
     boolean notReal=false; //正确
     boolean read2=1; //错误
     boolean notReal2=0; //错误

2.4字符型

2.4.1 Java字符型

通常意义上的字符，用单个引号括起来的单个字符

如'1','a','b'等等 

Java采用Unicode编码(即为全球统一语言编码)，均可以用十六进制表示编码值

char c = '\u0012'; 

转义字符，用’\n’来表示，即为转变之前的意义，但依然是个字符

char c='\n'; //表示换行符

3.基本类型转换

布尔类型不能与其它类型做任何转换
数值型、字符型可以相互转换，规则如下：
容量小的自动转换成表数范围容量大的,但byte,short,char不能相互转换,均转化成int做计算
容量大小排序为:byte,char,short<int<long<float<double
容量大转换为容量小的,要加强制转换符,此时容易丢失精度
多类型混合运算时，系统会自动转换成统一类型(大容量数据)后再进行计算，即先类型转换后计算

5、运算符与表达式

1.运算符

释义

用于表示数据的运算、赋值和比较的一系列符号我们称之为运算符。

分类

运算符按功能划分如下：

运算符类型	运算符
算术运算符	+，-，*，/，++，–，%
关系运算符	<，<=，>，>=，==，!=
布尔运算符	&&，
位运算符	&，
赋值类运算符	=， +=， -=， *=， /=， %=
字符串连接运算符	+
条件运算符(三目运算符）	? :
其他运算符	instanceof，new

1.1算术运算符

类型	描述	示例
++(自加运算符)	++在变量前面时，先做运算后赋值++在变量后面时，先做赋值后运算	i = 1, j; j = ++i; 则j=2;i = 1, j; j = i++; 则 j = 1
–(自减运算符)	同上	i = 1, j; j = - -i; 则 j = 0;i = 1, j; j = i- -; 则 j = 1;

1.2关系运算符

注意 ‘==’关系运算，其意义为全等，基本数据类型比较值，引用数据类型比较地址 

1.3逻辑运算符

与    &:两个操作数相与,如果都为true,则为true
或    |:两个操作数相或,有一个为true,则为true
异或  ^:相异为true,两个操作数不一样就为true,相同为false

短路&& 和 逻辑& 区别？

1.短路与,从第一个操作数推断结果，只要有一个为fase，不再计算第二个操作数
2.逻辑与,两个操作数都计算

短路|| 和 逻辑| 区别？

1.短路或,从第一个操作数推断结果，只要有一个为true，不再计算第二个操作数
2.逻辑或,两个操作数都计算

1.4赋值运算符

注意

1)当 "=" 两侧数据类型不一致时，适用默认转换或强制转换处理，如long num=20;int i=(int)num; 
2)特殊情况为:当byte,char,short被整赋值时,不需要进行强制类型转换,不超过取值范围即可。即一个自动装载的过程。
char c=100;byte b=20; //正确 
char c2=-99999;byte b2=128; //类型越界错误 

运算符	用法	c
+=	a+=b	a=a+b
-=	a-=b	a=a-b
*=	a*=b	a=a*b
/=	a/=b	a=a/b
%=	a%=b	a=a%b

1.5字符串连接运算符

"+" 可用于数值计算,当有一方是字符时,则为将左右两个数据转化成字符串连在一起。如int i=10+20;String j="10"+"20"。

当" +" 任意一侧为字符串时,系统将自动将两侧转化成字符串,做字符串链接操作。

当进行System.out.println(var)打印操作的时候,均自动转化为字符串进行输出。

1.6运算优先级

优先级	运算符分类	结合顺序	运算符
由高到低	分隔符	左结合	. [] ( ) ; ,
	一元运算符	右结合	! ++ – - ~
	算术运算符	左结合	* / % + -
	移位运算符		<< >> >>>
	关系运算符	左结合	< > <= >= instanceof == !=
	逻辑运算符	左结合	! &&
	三目运算符	右结合	布尔表达式?表达式1:表达式2
	赋值运算符	右结合	= *= /= %= += -= <<= >>= >>>= &= *=

【问】：做一道综合性强点的练习题，感受感受运算符优先级怎么样？

     int a = 5; 
     int b = 4; 
     int c = a++ - --b * ++a / b-- >> 2 % a--; 
c的值是多少？

2.表达式

表达式是指由(常量、变量、操作数)与运算符所组合而成的语句。

符合语法规则的运算符+操作数,即为表达式,如:5+3,2.0+3.0,a+b,3%2

表达式最终运行结果即为表达式的值,值的类型就是表达式的类型

运算符优先级,决定表达式的运算顺序

三目运算符:
    形如:x?y:z
    释义:计算x的值,若为true,则表达式的值为y;若为false,则表达式的值为z

6、流程控制结构

     程序控制结构是指以某种顺序执行的一系列动作，用于解决某个问题。程序可以通过控制语句来对程序实现选择、循环、转向和返回等流程控制。
     程序控制结构包括：顺序结构、分支结构、循环结构。

1. 顺序结构

   顺序结构程序就是按语句出现的先后顺序执行的程序结构。计算机按顺序逐条执行语句，当一条语句执行完毕，
   自动转到下一条语句。

如图：

示例：
int a = 11; //第一步
int b = 2; //第二步
int c = a+b; //第三步
System.out.println(“a+b的结果为：”+c); //第四步

2. 分支结构

     1)分支结构又称为选择结构。当程序执行到控制分支语句时，首先判断条件，根据条件表达式的值选择相应的语句执行（放弃另一部分语句的执行）。
     2)分支结构包括单分支、双分支和多分支三种形式。

如图：

2.1单分支

【语法格式】

if(布尔表达式){语句块;} 

说明：当语句块为一条语句时,大括号可以省略。只有布尔表达式为true时,才进入if语句中。

【示例】

int age = 20; 
if(age >= 18){
    
    System.out.println("成年人"); 
}

2.2双分支

【语法格式】

if(布尔表达式){ 
    语句块;//if分支 
}else{ 
    语句块;//else分支 
}

【示例】

int age = 20; 
if(age >= 18){
    
    System.out.println("成年人"); 
}else{
    
    System.out.println("未成年人"); 
}

2.3多分支-1

【语法格式】

if(布尔表达式){ 
    语句块; 
}else if(布尔表达式){ 
    语句块; 
}else{ 
    语句块; 
}

【示例】

int age = 20; 
if(age >0 && age <=18){
    
    System.out.println("未成年"); 
}else if(age > 18 && age <=40) {
    
    System.out.println("青年"); 
}else if(age > 40&& age<=50) {
    
     System.out.println("中年"); 
}else if(age > 50) {
    
     System.out.println("老年"); 
}else{
    
     System.out.println("见鬼了"); 
}

2.4多分支-2

【语法格式】

 switch (表达式) {
    case 值1:
        语句;
        break;
    case 值2:
        语句;
        break;
    default:
        语句;
        break;
 }

说明：

表达式的值只能为：char、byte、short、int类型、String、enum类型,其它类型均非法

break语句可以省略,但会出现switch穿透

default语句也可以省略,一般不建议省略,并且放置在最后

【示例】

public static void main(String[] args) {
    
     String type = "dog"; 
     switch(type) {
    
     case "cat": 
          System.out.println("喵"); 
          break;//注意break 
     case "dog": 
          System.out.println("旺"); 
          break; 
     case "sheep": 
          System.out.println("咩"); 
          break; 
     default: 
          System.out.println("哇!"); 
     } 
     System.out.println("switch执行结束！"); 
}

3. 循环结构

当程序执行到循环控制语句时，根据循环判定条件对一组语句重复执行多次。
循环结构的三个要素：循环变量、循环体和循环终止条件。
while、do…while、for三种循环。

如图：

3.1 while语句

【语法格式】

while(布尔表达式){ 
循环体; //一条或多条语句 
}

【示例】

int i = 1; 
while(i<=5) {
    
  System.out.println(i); 
  i++; 
}

3.2 do…while语句

【语法格式】

do { 
   循环体; 
}while(条件判断表达式);

【示例】

int i = 1; 
do{
    
  System.out.println(i); 
  i++; 
}while(i<=0); //注意分号

3.3 for语句

【语法格式】

for(表达式1;表达式2;表达式3) { 
    循环体; //一条或多条语句 
}

【示例】

for (int i=1; i<=5; i++) {
    
  System.out.println(i); 
}

3.4 break语句

强制退出某个循环体，结束循环语句的执行

【示例】

public static void main(String[] args) {
    
  for(int i=1; i<=10; i++) {
    
    System.out.println(i); 
    if(i == 5){
    
      break; //会跳出当前循环 
    } 
  } 
  //break跳到这里 
}

3.5 continue语句

终止某次循环过程，跳过continue语下方未执行的代码，开始下一步循环过程

【示例】

public static void main(String[] args) {
    
  for (int i=1; i<=10; i++) {
    
    if (i == 5) {
    
      continue; //会跳该次循环，跳到i++代码处 
    } 
    System.out.println(i); 
  } 
}

3.6 流程控制语句总结

条件判断语句:if语句、switch语句。
循环执行语句:do while语句、while语句、for语句。
跳转语句:break语句、continue语句、return语句。

控制语句类型	关键字	作用
选择结构语句	if、if else、else if、switch	通过开关机制，选择要执行的代码
循环结构语句	for、while、do while	通过循序机制，反复执行相同的代码段
改变语句执行序	break、continue	通过打断或继续机制，改变当前工码的执行顺序

三种循环结构的异同点:

用while和do…while循环时,循环变量在循环体之前初始化，而for循环一般在语句1进行初始化。

while 循环和for循环都是先判断表达式,后执行循环体;而do…while循环是先执行循环体后判断表达式。
也就是说do…while的循环体最少被执行一次，而while循环和for就可能一次都不执行。

这三种循环都可以用break语句跳出循环,用continue语句结束本次循环。

7、方发初识

1.释义

方法是组合在一起来执行操作语句的集合。

2.方法作用

1)	使程序变得更简短更清晰
2)	有利于程序维护
3)	提高程序开发效率
4)	提高代码重用性

3.方法创建与使用

【语法格式】

访问修饰符 返回值类型 方法名(参数列表){ 
        方法体 ;
}

【方法分类】

根据方法是否带参、是否带返回值，可将方法分为四类
1)	无参无返回值方法 
2)	无参带返回值方法 
3)	带参无返回值方法 
4)	带参带返回值方法

3.1无参无返回值方法

public void print(){
   
     System.out.println("大家好，我是我是papi酱");
     System.out.println("一个集美貌和才华与一身的女子");
 }

3.2无参带返回值方法

public int callForYou(){
   
     System.out.println("老铁,双击666！");
     return 666;
 }

3.3带参无返回值方法

public void printResult(int a, int b){
   
     int c = a + b;
     System.out.println("我只是打印结果而已,两数相加结果:"+c);
 }

3.4带参带返回值方法

public String ifAdult(int age){
   
     if(age >= 18){
   
         return "成年人";
     }else{
   
         return "未成年人";
     }
 }

3.5递归方法

释义

程序自身调用自身的编程技巧称为递归

递归四个特性

1.必须有可最终达到的终止条件，否则程序将陷入无穷循环； 
2.子问题在规模上比原问题小，或更接近终止条件； 
3.子问题可通过再次递归调用求解或因满足终止条件而直接求解； 
4.子问题的解应能组合为整个问题的解。 

技巧

找到递归实现的递归部分和终止部分

斐波那契数列

Fibonacci: 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 ... ... 
终止部分：F1=1,F2=1; 
递归部分为：F(n)=F(n-1)+F(n-2),其中n>2

图解斐波那契递归过程

Fibonacci递归实现代码

public class Test {
     
    public static long fibonacci(int n) {
   
        if(n==0||n==1) return 1;
        else {
   
            return fibonacci(n-1)+fibonacci(n-2);
        }
    }       
        public static void main(String[] args) {
   
            for(int i=0;i<10;i++) {
   
                long num = fibonacci(i);
                System.out.print(num+" ");
            }
            
        }  
}  

三、数组

1.数组

释义

数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。这些无序排列的同类数据元素的集合称为数组。

数组有一维数组和多维数组。

2. 一维数组

    1. 一维数组介绍

把int类型的四个数字1，2，3，4组织起来。

一维数组声明

两种声明格式

元素类型[] 变量名称 示例:int[] intArray; 
元素类型 变量名称[] 示例:int intArray[]; 
一行中允许声明多个数组
int[] array1,array2,array3;

一维数组初始化

数组初始化的过程就是为数据分配内存空间的过程。 

     静态初始化

声明数组时，对数组初始化，数组的大小会根据初始值的个数确定长度。 

【示例】

public static void main(String[] args) 
{
    
   String[] nameArray={
   "one","two","three"}; 
   for(int i=0;i<nameArray.length;i++){
    
        System.out.println(nameArray[i]); 
   } 
} 

     动态初始化

声明数组时，指定数组的长度即可。

【示例】

public static void main(String[] args) 
{
    
     int[] girlFriendArray=new int[10]; 
     for(int i=0;i<10;i++){
    
        girlFriendArray[i]=i; 
     } 
     for(int i=0;i<10;i++){
    
        System.out.println(girlFriendArray[i]); 
     } 
     
}

2. 一维数组的使用

2.1长度属性：length

int arr = new int[5]; //数组arr的长度属性，即arr.length=5

2.2下标访问数组元素

int arr = {12,23,5,34,7}; 
System.out.println("取出arr的第一个元素的值:"+arr[0]);

2.3数组遍历

下标循环

for(int 下标变量值=0;下标变量值<遍历对象的长度值;下标变量值++){ 
    循环体 
} 

【示例】

int[] arr = new int[5]; 
for(int i=0;i<arr.length;i++){
    
循环体 
} 

增强循环

for(元素类型t 元素变量x : 遍历对象obj){ 
    语句; 
} 

【示例】

int[] arr = {
   2,5,8,12,51}; 
for(int i : arr){
    
循环体 
}

3. 二维数组

1. 二维数组介绍

二维数组本质上是以数组作为数组元素的数组，即“数组的数组”。

int[][] a = {
  {1,3,5,7},{9,11,13,15},{17,19,21,23}}; 

2. 二维数组的声明

【语法格式】

类型说明符 数组名[常量表达式][常量表达式]

【常见二维数组声明问题】

二维数组的声明和初始化,严格按从高维到低维的顺序进行

int tempArray[][]=new int[][3]; //错误 
int tempArray[][]=new int[3][]; //正确 
int tempArray[][]=new int[3][4]; //正确

3.二维数组的使用

静态初始化

public static void main(String[] args) 
{
    
int[][] myArr={
   {
   1,2},{
   3,4},{
   5,6}}; 
}

动态初始化

public static void main(String[] args) 
{
    
  int[][] myArr=new int[10][10]; 
  for(int i=0;i<10;i++){
    
     for(int j=0;j<10;j++){
    
     	myArr[i][j] = (i+1)*j; 
  	} 
  } 
}

4. 数组总结

数组是一种引用数据类型
数组是一组类型相同的数据集合
数组元素的类型可以是基本类型或引用类型,但所有元素类型要一致
数组长度固定
数组元素可通过下标访问,下标从0开始

5. 数组排序

1. 自己写算法排序

(1) 冒泡排序

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有
再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢 “浮”到数列的顶端，
故名 “冒泡”。

【算法原理】

冒泡排序算法的运作如下：(从后往前)

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 
3. 针对所有的元素重复以上的步骤，除了最后一个。 
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

【算法描述】

public static void bubbleSort(int[] arr)
    {
   
        int temp = 0;
        int size = arr.length;
        for(int i = 0 ; i < size-1; i ++)
        {
   
            for(int j = 0 ;j < size-1-i ; j++)
            {
   
                if(arr[j] > arr[j+1])  //交换两数位置
                {
   
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                }
            }
        }
}

(2)选择排序

选择排序(Selection Sort)是一种简单直观的排序算法。它每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

【算法思想】

1. 在未排序序列中找到最小元素，存放到排序序列的起始位置 
2. 再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。 
3. 以此类推，直到所有元素均排序完毕。

【算法描述】

public static void selectSort(int[] numbers)
{
   
    int size = numbers.length; //数组长度
    int temp = 0 ; //中间变量
    for(int i = 0 ; i < size ; i++)
    {
   
        int k = i;   //待确定的位置
        //选择出应该在第i个位置的数
        for(int j = size -1 ; j > i ; j--)
        {
   
            if(numbers[j] < numbers[k])
            {
   
                k = j;
            }
        }
        //交换两个数
        temp = numbers[i];
        numbers[i] = numbers[k];
        numbers[k] = temp;
    }
}

2. 调用API排序方法

 int[] arr = {7,9,4,8,3,5};
 Arrays.sort(arr);

6. 数组元素查找

(1). 顺序查找

顺序查找是在一个已知无(或有序）序队列中找出与给定关键字相同的数的具体位置。

【算法原理】

让关键字与队列中的数从最后一个开始逐个比较，直到找出与给定关键字相同的数为止。

【算法描述】

public static int ordersearch(int[] arry,int des){
   
    int i=0;
    for(;i<=arry.length-1;i++){
   
        if(des==arry[i])
        return i;
    }
    return -1;
}

(2). 二分查找

二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好，占用系统内存较少；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。

【算法原理】

假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；
否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，
否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

【算法要求】

1)必须采用顺序存储结构。 
2)必须按关键字大小有序排列。

【算法描述】

public static int binarySearch(Integer[] srcArray, int des) {
   
    //定义初始最小、最大索引
    int low = 0;
    int high = srcArray.length - 1;
    //确保不会出现重复查找，越界
    while (low <= high) {
   
        //计算出中间索引值
        int middle = (high + low)/2 ;//防止溢出
        if (des == srcArray[middle]) {
   
            return middle;
        //判断下限
        } else if (des < srcArray[middle]) {
   
            high = middle - 1;
        //判断上限
        } else {
   
            low = middle + 1;
        }
    }
    //若没有，则返回-1
    return -1;
}

四、面向对象

1. 面向对象介绍

1. 面向过程与面向对象

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

2. 类和对象

Java是面向对象的程序设计语言，类是面向对象的重要内容，我们可以把类当成一种自定义数据类型，可以使用类来定义变量，这种类型的变量称为引用型变量。也就是说，所有类是引用数据类型。

2.1概念

面向对象的程序设计中有两个重要概念：类和对象。其中类是某一类对象的抽象。对象才是一个具体的实体。如：有一条狗叫”花花”，那么这条真实存在的狗才是对象，而”狗”是类，代表一类”花花”这样的实体。

抽象的重要性

抽象是继承和多态的基础。在抽象的过程中，我们获得是事物本质的东西和事物独特的东西，这样我们很自然的认识到抽象的事物和具体的事物之间是一种继承的关系，而他们之间的不同性可以通过多态来表现出来。

2.2定义类

2.2.1语法格式

 [权限控制符] class 类名 { 
    //零个到多个构造器 * 构造器定义 * 注意:构造器无返回值类型 
 [权限控制符] 类名(参数列表){}; 
    //零个到多个属性 * 属性定义 
 [权限控制符] [static | final] 属性类型 属性名; 
    //零个到多个方法 * 方法定义 
 [权限控制符] [abstract | final] [static] 返回值类型 方法名(参数表){}; 
 } 

提示：定义类的时候，不是必须显式写构造方法、属性、方法。

【示例】

定义一个学生类
属性:学号、姓名、年龄、班级
方法:学习、唱歌

public class Student{
   
	public Student(){
   
	//....
}

public Student(String name,int age){
   
		this.name = name;
		this.age = age;
}

public String name;
public int age;

//.....

public void study(){
   
	System.out.println(“爱学习”);
}
public void sing(){
   
	//唱歌
System.out.println(“爱唱歌”);

}
}

2.2.2对象的创建和使用

1)对象创建语法格式

类名 对象名 = new 类名(); 

示例

Student s = new Student();

2)操作对象的属性和方法

【语法格式】

使用类的属性: 对象名.属性 
实用类的方法: 对象名.方法名()

以上面学生类Student为例：

Student s = new Student(); 
s.age = 18; //为属性age赋值为18 
s.sing(); //调用sing方法

Student s = new Student(“小明”,18);
System.out.println(s.age);

2.3构造方法

构造方法是一种特殊的方法，它是一个与类同名且没有返回值类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。

特殊性

1)构造方法作用：构造出来一个类的实例，对构造出来的类的对象初始化。 
2)构造方法的名字必须与定义他的类名完全相同，没有返回类型，甚至连void也没有。 
3)系统会默认为类定义一个无参构造方法，即默认构造方法。若显式定义了构造方法，则系统不会提供默认无参构造函数。

示例

public class Constructor_01 {
   

	int age;

	public static void main(String[] args) {
   
		Constructor_01 c = new Constructor_01(12);
		System.out.println(c.age);
	}
     //有参构造方法
	public Constructor_01(int i) {
   
		age = i;
	}
     //无参构造方法
	public Constructor_01() {
   
		age = 18;
	}
}

思考

我们可以定义两个名称一样的属性么？不可以。那么两个方法的名称一样呢？这里的两个构造方法名称相同了，但是没有报错，
为什么呢？这就是方法重载。

2.4方法重载

特点

1)方法名一定要相同 
2)参数列表不同——参数类型、参数个数 
3)与方法的访问控制符和返回值无关

2.5对象的引用与this

引用

Student s = new Student(“张三”); 

上面的对象名s即为对象的引用，而 new Student(“张三”)才是张三对象。

this

总要有个事物来代表类的当前对象，就像C++中的this指针一样，Java中的this关键字就是代表当前对象的引用。

图例

它有三个主要的作用

1)在构造方法中调用其他构造方法 

比如：有一个Student类，有三个构造函数，某一个构造函数中调用另外构造函数，就要用到this()，而不可以直接使用Student()。

2)返回当前对象的引用 

3)区分成员变量名和参数名

2.6 static

static关键字的用途

被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

static方法

     static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说：

1. static是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。 
2. 在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。 
3. 虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。

static变量

     static变量也称作静态变量，静态变量和非静态变量的区别是：

1. 静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。 
2. 非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

二. JVM内存分析——案例

内存分配图

JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)

堆区:

1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。 
2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身。 
3.一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。

栈区:

1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中。 
2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。 
 3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。 
4.由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。

静态区/方法区:

1.方法区又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。 
2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。 
3.全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。

举例

Sample test1=new Sample(“测试1”);

3. 封装

1. 概念

什么是封装

封装是把对象的所有组成部分组合在一起，封装使用访问控制符将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

作用

适当的封装可以让代码更容易理解和维护，也加强了代码的安全性。

2. 访问控制符

访问控制符用来控制父类、子类间，不同包中的类间数据和方法的访问权限。

包括private、protected、public和默认四中类型。其访问权限如下：

访问控制符	同一类中	同一包中	同一子类中	其他
private	是	否	否	否
default	是	是	否	否
protected	是	是	是	否
public	是	是	是	是

4. 继承

1. 概念

继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的属性和行为。

1.1 Java继承特点

1)	Java是单继承的，不支持多继承。这样使得Java的继承关系很简单，一个类只能有一个父类，易于管理程序。同时一个类可以实现多个接口，从而克服单继承的缺点。
2)	继承关系是传递的
3)	private修饰的成员变量或方法是不能被继承的

1.2解决什么问题

提高了代码的效率，避免了代码重写。

2. 语法格式

[修饰符] class 子类 extends 父类 { 
        //类体 
}

【示例】
实现一个继承，定义学生类为父类，定义一个大学生类作为子类。

//父类
public 

本文标签： 知识点基础JavaSE