Java SE语言集合

Java基础
- 编写Hello,world
- 注释
- 标识符
- 数据类型
- - 基本类型
  - 引用类型
- 拓展
- - 整数进制
  - 浮点数
  - 字符
  - 转义字符
  - 布尔值
- 变量作用域
- 常量
- - 变量的命名规范
- 运算符
- 包机制
- javaDoc
- Scanner对象
- 顺序结构
- 选择结构
- - 1. if单选择结构
  - 2. if双选择结构
  - 3. if多选择结构
  - 4. 嵌套的if结构
  - 5. switch多选择结构
- 循环结构
- - 1. while循环
  - 2. do...while循环
  - 3. for循环
  - 增强for循环
- break和continue
Java方法
- 什么是方法
- 方法的定义
- 方法的调用
- 方法的重载
- - 方法重载的规则
- 命令行传参（了解即可）
- 可变参数
- 递归
- - 递归结构
数组
- 简单的内存分析
- - Java内存
- 数组的特点
- 数组的使用
- 多维数组
- - 二维数组
- Arrays类
- 冒泡排序
- 稀疏数组
面向对象编程（oop）
- 回顾调用方法
- 类和对象的关系
- - 如何创建一个对象
  - - 构造器
- 封装
- 继承
- - object类
  - super
  - 方法重写
- 多态
- instanceof
- 类型转换
- 抽象类
- 接口
异常机制

Java基础

编写Hello,world

快速打印System.out.println()可以用：syso + Alt键 + /

public class Helloworld {public static void main(String[] args) {// TODO Auto-generated method stubSystem.out.println("Hello，world");       }
}

注释

//注释
/* 多行注释：可以用于注释一段话 */
/** 文档注释 */

标识符

Java所有的组成部分都需要名字，名字不要用到关键字
所有标识符只能以字母(大小写都行)，美元符($)，或者下划线（_）开始
标识符是区分大小写的，如Ao和ao是不同的部分

数据类型

要求所有变量符合严格规定，都必须定义后使用

     int a=10;//int a="hai"; "hai"是string类型会报错

基本类型

整数类型	浮点（小数）类型	字符类型	boolean类型
byte	float	char	true
short	double		false
int
long

*Long类型要在数字后面加个L进行区分

*char类型只有一个字符，如：char a=‘中’ ，但"中国"会报错（String是个类，不是关键字）

引用类型

类
接口
数组

拓展

整数进制

二进制0b 八进制0 十六进制0x

int  i= 10;
int  a= 010;
int  a1= 0b101;
int  a2= 0x10;

浮点数

float f =0.1f;
double d = 1.0/10;
System.out.println(f==d);
//结果是false
float d1 = 23232323112321f;
double d2 = d1 + 1;
System.out.println(d1==d2);
//结果是true
//浮点数表现出来的是有限的，没有办法精确
//用BigDecimal 数学类来精确计算

字符

强制转换（类型）变量名

char c1 ='a';
System.out.println((int)c1);

自动转换低到高

低——————————————————>高

byte,short,char–>int–>long–>float–>double

*注意：
1. 不能对布尔值转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，要用强制转换
4. 转换的时候可能最在内存溢出，或者精度问题

转义字符

// \t 制表符
// \n 换行

布尔值

boolean flag = true;
if(flag==true){}
if(flag){} //都是一样的都==true

变量作用域

类变量(用在class里的变量)
实列变量
局部变量(用在方法里)

public class HelloWorld {//属性
static int a=0;  //类变量
String str="hello";  //实列变量//实列类型:从属于对象;如果不自行初始化,这个类型的默认值 0 0.0//布尔值:默认为false//除了基础类型,其余默认值都是null
public void method() {int a=0;  //局部变量//局部变量:必须声明和初始化值}
}

常量

初始化后不能再改变值! 不会变动的值

final 常量名 = 值;
final double P = 3.1415;

常量名一般使用大写字符

变量的命名规范

类成员变量: 首字小写和驼峰原则,例: maxMize
局部变量:首字小写和驼峰原则
变量:大写字母和下划线,例:MAX_EFFORTS
类名:首字大写和驼峰原则
方法名:首字小写和驼峰原则,例:runRun()

运算符

算数运算符
赋值运算符:=
关系运算符:> < == >= <= != instanceof
逻辑运算符:&& || !

位运算符:& | ^ ~ >> << >>> 这个知识点了解就好了

A= 0011 1100
B= 0000 1101
A&B == 0000 1100  //和
A|B == 0011 1101  //或
A^B == 0011 0001  //相同为0,不同为1
~B == 1111 0010   //相反
//   << 相当于*2   >> 相当于/2System.out.println(2<<3); //结果为16

条件运算符:? :

// x ? y : z
//如果x==true,则结果为y,否则结果为z

扩展赋值运算符:+= -= *= /=

很多运算可以使用Math类来操作

包机制

Java的包机制相当于一个文件夹

一般利用公司域名倒置为报名; 如:com.hai.www

定义包: package com.hai.www;
导入包:import com.hai.www;

javaDoc

Javadoc命令是用来生成自己API文档的

/** * @author 海量的海*/
//加在哪个部分上面就是那个部分的注释

dos命令行生成javadoc文档: javadoc 参数 java文件

例:javadoc -encoding UTF-8 -charset UTF-8 dos.java

或者运用idea生成javadoc文档

Scanner对象

scanner对象用于实现与用户进行交互

Scanner scanner = new Scanner(System.in);//接收输入
//next和nextline的区别
System.out.println("使用next接收：");
//判断用户有没有输入字符串
if(scanner.hasNext()) {String str = scanner.next();//Alt+shift+L快速创建对象System.out.println("输出内容为："+str);}
//输入hello world,结果为hello
//-----------------------------------------
System.out.println("使用nextline接收：");
if(scanner.hasNextLine()) {String str = scanner.nextLine();System.out.println("输出内容为："+str);
}
输入hello world,结果为hello world
//凡是属于输入输出流的类如果不关闭会一直占用资源，用完要关掉
scanner.close();

next()：
1. 一定要读取到有效字符后才会结束输入
2. 对输入有效字符之前遇到的空白，next（）方法会自动将其弃掉
3. 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
4. next（）不能得到带有空格的字符串
nextLine()：
1. 以Enter为结束符，也就说nextLine（）方法返回的是回车键之前的所有字符
2. 可以获得空白

顺序结构

Java的基本结构就是顺序结构，一般是按照顺序一句一句（从上到下依次）执行

它是如何一个算法都离不开的一种基本结构

选择结构

if单、双、多选择结构
嵌套的if结构
switch多选择结构

1. if单选择结构

if(布尔表达式){//如果布尔表达式为true将执行
}

2. if双选择结构

if(){//如果布尔表达式为true将执行
}else{//如果布尔表达式为false将执行
}

3. if多选择结构

if(布尔表达式1){//如果布尔表达式1为true将执行
}else if(布尔表达式2){//如果布尔表达式2为true将执行
}else if(布尔表达式3){//如果布尔表达式3为true将执行
}else{//如果布尔表达式为false将执行
}

4. 嵌套的if结构

if(布尔表达式1){//如果布尔表达式1为true将执行if(布尔表达式2){//如果布尔表达式2为true将执行   }
}

5. switch多选择结构

switch case语句判断一个变量与一系列值中的某个值是否相等

switch(表达式){case value://语句break;  //可写不写，看你要不要case value:break;default://都不满足则执行
}

从Java SE 7 开始 switch可以比较String

循环结构

while 循环
do…while 循环
for 循环

1. while循环

while(布尔表达式){//循环内容
}

只要布尔表达式为true，循环一直执行
我们一般需要一个让表达式失效的方式来结束循环
循环条件一直为true就会造成无限循环（死循环），一般尽量避免

2. do…while循环

do{//语句
}while()

先执行后判断

do…while至少能执行一次

3. for循环

for(初始化;布尔表达式;更新){  //更新，如a++//语句
}
//死循环
for( ; ; ){}

for循环是最有效，最灵活的循环结构

九九乘法表

for(int j=1;j<=9;j++) {for(int i=1;i<=j;i++) {System.out.print(j+"*"+i+"="+(j*i)+"\t");  //print不回车}System.out.println(); //println自带回车
}

增强for循环

int[] numbers = {10,20,30,40};
//一般for循环
for(int i=0;1<4;i++){System.out.println(numbers[i]);
}
//增强for循环
//遍历数组的元素
for(int x:numbers){System.out.println(x);
}
//输出结果一样

break和continue

break强制退出循环，终止全部循环程序

continue只是终止某一次循环过程，接着下一句循环语句进行

关于goto关键字（不用了解）

Java中没有goto，但break和continue中可以看到goto的影子----带标签的break和continue

Java方法

什么是方法

System.out.println()中是调用system类中的out对象中的println（）方法

Java方法是语句的集合，它们在一起执行一个功能

方法是解决一类问题的步骤的有序组合
方法包含于类对象中
方法在程序中被创建，在其他地方被引用

例如：main方法可以用main+Alt+/ 快速创建
```
//main方法
public static void main(String[] args){}
```

方法的定义

方法包含一个方法头和一个方法体（形参和实参）

修饰符  返回值类型  方法名(参数类型  参数名){方法体return 返回值;  //return 0; 结束方法
}
//例：
public static int add(int a,int b){  //形式参数，用来定义的return a+b;
}
//实际参数，调用add方法用的参数
int sum = add(1,2);

方法的调用

调用方法：对象名.方法名（实参）
Java支持两种调用方法的方式，根据方法是否返回值来选择
1. 当方法返回一个值时，方法调用通常被当作一个值
2. 如果方法返回值是void，方法调用一定是一条语句

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

public static int add(int a,int b){}
public static int add(double a,double b){}

方法重载的规则

方法名必须相同
参数列表必须不同
方法的返回类型可以相同也可以不同
仅仅返回类型不同不足以成为方法的重载

命令行传参（了解即可）

靠传递命令行参数给main()函数实现

可变参数

JDK1.5开始，Java支持传递同类型的可变参数给一个方法
在指定参数类型后面加一个省略号（…）
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

public static void add(int a,int... b){}  //...一定要在最后

递归

自己调用自己

递归结构

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法

//实现数的阶乘 如3!==3*2*1
//3 3*f(2)  f(2)=2*f(1)  f(1)=1
public static int f(int n) {if(n<=0) {System.out.println("输入正整数");return 0;}if(n==1) {return 1;}else {return n*f(n-1);}}

数组

什么是数组

数组是相同类型数据的有序集合，每个数组中的元素可以通过下标来访问

声明创建数组

int[] a = new int[10];

赋值

a[0]=1;

如果不赋值则为默认值—0

获取数组长度

a.length

简单的内存分析

Java内存

堆：
- 存放new的对象和数组
- 可以被所有的线程共享，不会存放别的对象引用
栈：
- 存放基本变量类型
- 引用对象的变量
方法区：
- 可以被所有的线程共享
- 包含了所有的class和static变量

三种初始化

静态初始化

int[] a={1,2,3};

动态初始化

int[] a = new int[10];
a[0]=1;

数组的默认初始化

数组的特点

长度一定，一旦被创建，大小不可改变
元素必须是相同类型
数组中的元素可以是如何数据类型，包括基本类型和引用类型
数组对象本身实在堆里的

数组的使用

For-Each循环(增强for)

int[] a = new int[10];
for(int b:a) {System.out.println(b);

数组作方法入参

public static void c(int[] a) {for(int i=0;i< a.length;i++) {System.out.print(a[i]+" ");}

数组作返回值

多维数组

二维数组

int[][] a= {{1,0},{1,1},{2,0},{2,1}};

可以理解为几行几列，a.lengh=4 ， a[0].lengh=2

多维和二维一样，一直嵌套，如三维：a={{{1,2},{1,1}},{{2,1},{2,0}}};

Arrays类

打印数组元素

int[] a = new int[10];
System.out.println(Arrays.toString(a));

给数组赋值：fill方法

Arrays.fill(a, 1);

对数组排序：sort方法，按升序
比较数组：equals方法比较数组中元素是否相等
查找数组元素：binarySearch方法能对排序好的数组进行二分查找法操作

冒泡排序

比较数组中两个相邻的元素的大小，小的向前/后，大的向后/后

public static void d(int[] arrays) {int temp=0;for(int i=0;i<arrays.length-1;i++) {  //判断要循环几次for(int j=0;j<arrays.length-1-i;j++) {  //每次把要比较的元素中最小的向最后排if(arrays[j+1]>arrays[j]) {//两个数交换temp=arrays[j];arrays[j]=arrays[j+1];arrays[j+1]=temp;}}}
}

优化思路

public static void d(int[] arrays) {boolean flag=false;int temp=0;for(int i=0;i<arrays.length-1;i++) {for(int j=0;j<arrays.length-1-i;j++) {if(arrays[j+1]>arrays[j]) {//两个数交换temp=arrays[j];arrays[j]=arrays[j+1];arrays[j+1]=temp;flag=true;}}if(flag==false){break;}}
}

还有一个知识点：稀疏数组

稀疏数组

稀疏数组就是压缩数组中有用的元素，去除重复的元素

int[][] a1 = new int[11][11];a1[1][2] = 1;a1[2][3] = 1;for(int[] b:a1) {for(int b1:b) {System.out.print(b1+"\t");}System.out.println();}System.out.println("=============");int sum = 0;for(int i=0;i<a1.length;i++) {for(int j=0;j<a1[i].length;j++) {if(a1[i][j]!=0) {sum++;}}}int[][] a2 = new int[sum+1][3];a2[0][0]=a1.length;a2[0][1]=a1[0].length;a2[0][2]=sum;int count =0;for(int i=0;i<a1.length;i++) {for(int j=0;j<a1[i].length;j++) {if(a1[i][j]!=0) {count++;a2[count][0] = i;a2[count][1] = j;a2[count][2] = a1[i][j];}}}System.out.println("打印稀疏数组：");for(int[] b:a2) {for(int b1:b) {System.out.print(b1+"\t");}System.out.println();}System.out.println("========================");System.out.println("还原");int[][] a3 = new int[a2[0][0]][a2[0][1]];for(int i=1;i<a2.length;i++) {a3[a2[i][0]][a2[i][1]] = a2[i][2];}for(int[] b:a3) {for(int b1:b) {System.out.print(b1+"\t");}System.out.println();}

面向对象编程（oop）

面向过程

之前的学习都算是面向过程，第一步做什么，第二步做什么，处理一些简单的问题，是具体的

什么是面向对象

面向对象的本质：以类的方式组织代码，以对象的组织（封装）数据
抽象
三大特点：
1. 封装
2. 继承
3. 多态

回顾调用方法

静态方法：(static) ,直接调用**（main方法也是static）**：类名.方法名();
非静态方法**:要先实例化类（new）** ，之后再调用方法：对象名.方法名();

注：

// 和类一起加载的
public static void a() {b(); //会报错
}
// 类实例化后才存在
public void b() {}

值传递和引用传递？

类和对象的关系

类是一个抽象的数据类型，它是对某一类十五整体描述/定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例，例：张三是人的一个具体实例

如何创建一个对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。并且构造器有2个特点：
1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void

构造器

public class B {//一个类即使什么都不写，它也会存在一个方法：默认构造器int a;public B(){  //这个就是构造器//1.使用new关键字，本质是在调用构造器this.a = 1;}//有参构造：一旦定义了有参构造，new无参就一定要显示定义//如： b b = new b(1);public B(int a){this.a = a;  //第一个a是类属性的a，第二个a是构造器中的a}
}

封装

该露的露，该藏的藏（高内聚，低耦合）

属性私有，get/set

public class B {private int a; //属性私有
//提供一些可以操作私有属性的方法：get/set
//get  获得这个数据
public int getA(){return this.a;
}
//set  给这个数据设置值
public void setA(int a){this.a = a;
}
}
//====================================
public static void main(String[] args) {B b1 = new B();b1.setA(1);b1.getA();
}

封装的意义：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
增强系统可维护

继承

继承的本质是对一批类进行抽象

extends的意思是“扩展”，子类是父类的扩展，子类继承了父类就会拥有父类的全部方法(除了私有)

Java中类只有单继承，没有多继承

object类
super
方法重写

public class Son extends Father{}

object类

在Java中类一般都默认继承在object类下

super

this关键字是调用当前类中的属性，而super关键字是调用父类中的属性

super注意点：

super调用父类的构造方法，必须在构造方法中的第一行
super必须只能出现在子类的方法或者构造方法中
super和this不能同时调用构造方法

VS this：

代表的对象不同
前提不同：this没有继承也能使用，而super只能在继承条件下使用
构造方法不同：this是本类的构造，而super是父类的构造

方法重写

public class Father{public void text(){}
}
public class Son extends Father{@Override //这个是重写的注释public void text(){}
}
Son s = new Son();
s.text();
Father f = new Son(); //子类重写了父类的方法
f.text();  //都显示子类写的方法

重写前提：需要有继承关系，子类重写父类的方法

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小：public>protected>default>private
抛出异常：范围可以缩小但不能扩大
只有非静态的方法才算重写
final常量不能重写，私有的不能重写

为什么要重写：父类的功能子类不一定需要或者不满足

多态

//能调用自己的方法和父类的
Son s = new Son();
//可以指向子类，但不能调用子类独有的方法
Father f = new Son();

多态是方法的多态，属性没有多态
父类和子类有联系
存在的条件：继承关系，方法需要重写，父类引用指向子类对象

instanceof

判断两个类是否有继承关系

Object Object = new HelloWorld();
System.out.println(Object  instanceof Object); //true
System.out.println(Object  instanceof HelloWorld); //true

类型转换

public class Father{}
public class Son extends Father{public void run(){}
}Father f = new Son();
((Son)f).run(); //类型转换，这一行等于以下这两行
//Son s = (Son)f;
//s.run();

把父类转换为子类，向下转型，强制转换
把子类转换为父类，向上转型

抽象类

只有方法名字，没有方法的实现

特点：

不能new这个抽象类，只能靠子类去实现它
抽象方法必须在抽象类中
普通方法可以写在抽象类中

public abstract class Action{}

接口

public interface GuestDao { //接口int sell(); //会默认为抽象方法
}

public class OfflineBookingDao implements GuestDao{@Overridepublic int sell() {}
}

implements实现接口

接口可以实现多继承：implements X,V{}

作用：

约束
定义一些方法，让不同的人实现
接口不能被实例化，接口中没有构造方法
implements可以实现多个接口
必须重写接口中的方法

异常机制

抛出异常
捕获异常
异常处理五个关键字：try，catch，finally，throw，throws

try {//正常代码写在这Object = new HelloWorld();
} catch (Exception e1) {// TODO Auto-generated catch blocke1.printStackTrace();
}
//主动抛出异常
protected Object clone() throws CloneNotSupportedException {// TODO Auto-generated method stubreturn super.clone();
}

自定义异常

用户自定义异常，只需继承Exception类即可

程序中步骤：

创建自定义异常类
在方法中通过throw关键字抛出异常现象
如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理
在出现异常方法的调用者中捕获并处理异常