java入门基础
语法基础
变量和常量
字符串
tring 类型是引用类型
字符串拼接可以直接用加号连接
自动类型转换
向上类型转换，是小类型到大类型的转换。
和C语音一样
int类型可以自动转换为double
但是double需要强制转换才能转换为int
强制类型转换
向下类型转换，是大类型强制转换到小类型的转换。
语法：( 数据类型 ) 数值
int b = (int)a;
将double的值转换为int会直接从小数点处截断
常量
final String STR = "常量";注释
分为文档注释、多行注释、单行注释
package com.imooc;
/**
* 这是文档注释
* @author wwb
* @version v1.0
*/
public class Demo01 {
/*
* 这是多行注释
* 多行注释
*/
public static void main(String[] args) {
// 单行注释
System.out.println("Hello JAVA!");
}
}PS：使用文档注释时还可以使用 javadoc 标记，生成更详细的文档信息：
@author 标明开发该类模块的作者
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@param 对方法中某参数的说明
@return 对方法返回值的说明
@exception 对方法可能抛出的异常进行说明
根据注释自动生成API帮助文档
可以使用javadoc命令从文档注释中提取内容，生成程序的 API 帮助文档。
javadoc -d doc Demo01.java
常用运算符
运算符是一种“功能”符号，用以通知 Java 进行相关的运算。
Java 语言中常用的运算符可分为如下几种：
算术运算符
赋值运算符
比较运算符
逻辑运算符
条件运算符
算术运算符
赋值运算符
比较运算符
逻辑运算符
条件运算符
条件运算符（ ? : ）也称为 “三元运算符”。
语法形式：布尔表达式 ? 表达式1 : 表达式2
运算过程：如果布尔表达式的值为 true ，则返回 表达式1 的值，否则返回 表达式2 的值
例如：
运算符的优先级
级别为 1 的优先级最高，级别 11 的优先级最低。
流程控制语句
与C/C++一致
数组
基础语法
语法：
int[] scores = {1,2,3,4,5}; // 声明并分配空间&赋值
// 等价于
int[] scores = new int[]{1,2,3,4,5}; // 后面[]中不能指定大小
// 声明
int[] scores; // 或者下面这种
double height[];
String[] names;分配空间：
scores = new int[5]; // 长度为5的整数数组
height = new double[5];
names = new String[5];
int[] scores = new int[5]; // 声明并分配空间赋值或操作数组：
scores[1] = 80; // 赋值
System.out.println(scores[1]); // 输出使用Arrays类操作数组
Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等。
需要导入Arrays类
import java.util.Arrays;
Arrays 中常用的方法：
排序
Arrays.sort(数组名); //升序将数组转换为字符串
Arrays.toString(数组名);可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开。
用foreach操作数组
foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。从英文字面意思理解 foreach 也就是“ for 每一个”的意思。
语法：
for (元素类型 元素变量:遍历对象) {
// 执行代码
}
// 例如
int[] scores = { 89, 72, 64, 58, 93 };
for (int score : scores) {
System.out.println(score);
}二维数组
声明数组并分配空间
语法：
数据类型[][] 数组名 = new 数据类型[行的个数][列的个数];
// 或者
数据类型[][] 数组名;
数组名 = new 数据类型[行的个数][列的个数];
// 声明的同时赋值
数据类型[][] 数组名 = {{1,2,3},{4,5,6}}; // 两行三列
int[][] arr = {{1,2,3},{4,5,6}}
arr.length // 行数
arr[0].length // 第一个元素的数组长度(列数)方法
基本语法
所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。
语法：
访问修饰符 返回值类型 方法名(参数列表) {
// 方法体
}其中：
访问修饰符：方法允许被访问的权限范围， 可以是 public、protected、private 甚至可以省略 ，其中 public 表示该方法可以被其他任何代码调用，其他几种修饰符的使用在后面章节中会详细讲解滴
返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，并且在方法体中使用 return 语句返回值
方法名：定义的方法的名字，必须使用合法的标识符
参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开
根据方法是否带参、是否带返回值，可将方法分为四类：
- 无参无返回值方法
- 无参带返回值方法
- 带参无返回值方法
- 带参带返回值方法
public class HelloWorld {
public static void main(String[] args) {
// 创建对象，对象名为hello
HelloWorld hello = new HelloWorld();
// 调用方法
hello.say();
}
/*
* 定义无参无返回值的方法
*/
public void say() {
System.out.println("hello!");
}
}方法的重载
如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载，也可称该方法被重载了。
当调用被重载的方法时， Java 会根据参数的个数和类型来判断应该调用哪个重载方法，参数完全匹配的方法将被执行。
（与C++的重载一致）
判断方法重载的依据：
1、 必须是在同一个类中
2、 方法名相同
3、 方法参数的个数、顺序或类型不同
4、 与方法的修饰符或返回值没有关系
例子：
public class HelloWorld {
public static void main(String[] args) {
// 创建对象
HelloWorld hello = new HelloWorld();
// 调用无参的方法
hello.print();
// 调用带有一个字符串参数的方法
hello.print("tom");
// 调用带有一个整型参数的方法
hello.print(18);
}
public void print() {
System.out.println("无参的print方法");
}
public void print(String name) {
System.out.println("带有一个字符串参数的print方法，参数值为：" + name);
}
public void print(int age) {
System.out.println("带有一个整型参数的print方法，参数值为：" + age);
}
}类和对象
类的定义
public class Telephone {
// 属性
float screen;
float cpu;
float mem;
// 方法
void call() {
System.out.println("calling...");
}
}类可以实例化为对象
// 类名 对象名 = new 类名(); // 构造方法
Telephone phone = new Telephone();成员变量和局部变量
成员变量在类中定义（不一定要赋初值）。可以被同一个类的方法访问到。
局部变量在方法中定义（需要赋初值）。只能在本方法内访问。
构造方法
- 使用
new 构造方法();来创建一个新的对象。 - 构造方法是定义在Java类中的一个用来初始化对象的方法。
- 构造方法与类名相同且没有返回值。
- 语法：
public 构造方法名 (参数) { // 构造方法名与类名相同
// 初始化代码
}- 当没有指定构造方法时，系统会自动填加无参的构造方法。若有指定则不会添加。
- 构造方法也可以重载
static
我们可以基于一个类创建多个该类的对象，每个对象都拥有自己的成员，互相独立。然而在某些时候，我们更希望该类所有的对象共享同一个成员。此时可以用static修饰。
Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。推荐使用类名访问。
静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收。
与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。
注意：
- 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。
- 如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
- 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。
- 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
静态初始化块
在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。
需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象时并未执行静态初始化块。
封装
概念
将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法(set、get)来实现对隐藏信息的操作和访问
用包管理Java中的类
作用
- 管理Java文件；
- 解决同名文件冲突；
定义包
必须放在Java源程序的第一行，包名间可以用‘.’隔开。
比如：com.imooc.MyClass代表最底层是com，然后是imooc，按层次结构命名比较好。
包的使用
可以通过
import关键字，在某个文件中使用其他文件中的类。Java中，包的命名规范是全小写字母
加载某个包下面所有的文件可以这么写
import com.imooc.*
访问修饰符
可以修饰属性和方法的访问范围
| 访问修饰符 | 本类 | 同包 | 子类 | 其他 |
|---|---|---|---|---|
| private | √ | |||
| 默认 | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
this关键字
this关键字代表当前对象
封装对象的属性的时候，经常会用this关键字
内部类
内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
作用：
- 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
- 内部类的方法可以直接访问外部类的所有数据，包括私有的数据
- 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
内部类可以分为：
- 成员内部类
- 静态内部类
- 方法内部类
- 匿名内部类
//外部类HelloWorld
public class HelloWorld {
// 内部类Inner，类Inner在类HelloWorld的内部
public class Inner {
// 内部类的方法
public void show() {
System.out.println("welcome to imooc!");
}
}
public static void main(String[] args) {
// 创建外部类对象
HelloWorld hello = new HelloWorld();
// 创建内部类对象
Inner i = hello.new Inner();
// 调用内部类对象的方法
i.show();
}
}成员内部类
内部类中最常见的就是成员内部类，也称为普通内部类。
内部类可以使用任意访问控制符
内部类中定义的方法可以直接访问外部类中的任意数据，不受访问控制符影响
使用内部类必须先创建一个外部类的对象，然后通过外部类来new一个内部类对象，不能直接new一个内部类对象
编译后会产生两个class
外部类不能直接使用内部类的方法，可以先创建内部类对象，然后通过内部类的对象访问其成员变量和方法
如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：
Outer.this.var
静态内部类
静态内部类是 static 修饰的内部类，这种内部类的特点是：
- 静态内部类不能直接访问外部类的非静态成员，但可以通过
new 外部类().成员的方式访问 - 如果外部类的静态成员与内部类的成员名称相同，可通过
类名.静态成员访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员 - 创建静态内部类的对象时，不需要外部类的对象，可以直接创建
内部类 对象名= new 内部类();
//外部类
public class HelloWorld {
// 外部类中的静态变量score
private static int score = 84;
// 创建静态内部类
public static class SInner {
// 内部类中的变量score
int score = 91;
public void show() {
System.out.println("访问外部类中的score：" + HelloWorld.score );
System.out.println("访问内部类中的score：" + score);
}
}
// 测试静态内部类
public static void main(String[] args) {
// 直接创建内部类的对象
SInner si = new SInner();
// 调用show方法
si.show();
}
}方法内部类
方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
继承
概念
继承是一种类与类的关系，Java中的继承是单继承。
子类拥有父类的所有属性和方法，实现代码复用。
语法：
class Dog extends Animal {
// 代码...
}方法的重写
子类继承父类时，可以对父类的方法进行重写，当调用方法时会优先调用子类的方法。
语法规则：
方法的返回类型，方法名，参数类型及个数都要与父类继承的方法相同，才叫方法的重写。
继承的初始化顺序
- 初始化父类再初始化子类
- 先执行初始化对象中的属性，再执行构造方法中的初始化
final关键字
用final修饰的东西不可以被修改
final可以修饰类、方法、属性和变量
- 修饰类，则该类不允许被继承
- 修饰方法，则该方法不允许被重写
- 修饰属性，则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）或在构造方法中赋值（但只能选其一）
- 修饰变量，则该变量只能赋一次值，即为常量
super关键字
在对象内部使用，可以代表父类对象。
子类的构造过程当中必须调用其父类的构造方法。
如果子类的构造方法中没有显式调用父类的构造方法，则系统默认调用父类无参的构造方法。
如果显式地调用构造方法，必须在子类构造方法的第一行。
如果子类构造方法中没有显式地调用父类的构造方法，而父类中又没有无参的构造方法，此时编译器会报错。
Object类
Object类是所有类的父类，Object类中的所有方法都可以在所有子类中调用。
toString()
返回对象的哈希code码（对象地址字符串）
可以重写toString()方法来输出对象的属性。
equals()
比较的是对象的引用是否指向同一块内存地址。
同一个类生成的两个对象，就算值是一摸一样的，但是通过equals()方法判断出来的结果也是false，也可以用==，结果和调用equals()方法是一样的。只有两者是同一个对象的时候才返回true。
如果需要判断两个对象值是否相等，需要重写equals方法。
多态
对象的多种形态
引用的多态
父类的引用可以指向本类的对象。
父类的引用可以指向子类的对象。
Animal obj1 = new Animal(); // 父类的引用可以指向本类的对象
Animal obj2 = new Dog(); // 父类的引用可以指向子类的对象，这种形式称为多态
// Dog obj3 = new Animal(); // 错误的 方法的多态
创建本类对象时，调用的方法为本类方法。
创建子类对象时，调用的方法为子类重写的方法或者继承的方法，但是父类不能调用子类中独有的方法。
instanceof关键字
进行多态中的引用类型转换时，可以用instanceof来判断是否能进行转换。
抽象类
语法：
抽象类前使用abstract关键字修饰。
作用：
限定子类必须实现某些方法，但不关注实现细节。
应用场景：
- 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
- 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。
使用规则：
- abstract定义抽象类
- abstract定义抽象方法，只有声明，不需要实现
- 包含抽象方法的类是抽象类
- 抽象类中可以包含普通的方法，也可以没有抽象方法
- 抽象类不能直接创建，可以定义引用变量
public abstract class Telephone {
public abstract void call();
public abstract void message();
}
// 然后创建子类继承他，重写方法就好了接口
概念：
接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。
类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
语法：
[修饰符] interface 接口名 [extends 父接口1,父接口2...]
{
// 常量的定义
public static final int var; // 即使不写前面的修饰，编译器也会自动加上
// 抽象方法的定义
public abstract void func(); // 即使不写前面的修饰，编译器也会自动加上
}
// 接口是用来被继承、实现的，所以修饰符一般建议用public使用：
一个类可以实现一个或多个接口，实现接口使用implements关键字。Java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。
// 如果要继承父类，extends要在implements前
[修饰符] class 类名 extends 父类 implements 接口1,接口2...
{
// 如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
}异常
try-catch 和 try-catch-finally
try{
// 执行代码
} catch (InputMismatchException e) {
// 处理错误
e.printStackTrace();
} catch (ArithmeticException e) {
// ...
} finally {
// 最终要执行的代码
}异常的抛出
public void divide(int a,int b) throws Exception { // 声明会抛出什么类型的异常
if (b == 0)
throw new Exception("除数为0"); // 抛给上一层，交由上层处理
else
System.out.println("结果为：" + a/b);
}自定义异常
public class myException extends Exception {
public myException(String message) {
super(message);
}
}包装类
为了让基本数据类型也具备对象的特性， Java 为每个基本数据类型都提供了一个包装类，这样我们就可以像操作对象那样来操作基本数据类型。
自动装箱/拆箱
public class HelloWorld {
public static void main(String[] args) {
// 定义double类型变量
double a = 91.5;
// 手动装箱
Double b = new Double(a);
// 自动装箱
Double c = a;
System.out.println("装箱后的结果为：" + b + "和" + c);
// 定义一个Double包装类对象，值为8
Double d = new Double(87.0);
// 手动拆箱
double e = d.doubleValue();
// 自动拆箱
double f = d;
System.out.println("拆箱后的结果为：" + e + "和" + f);
}
}日期相关
Date和SimpleDateFormat
在程序开发中，经常需要处理日期和时间的相关数据，此时我们可以使用 java.util 包中的 Date 类。这个类最主要的作用就是获取当前时间。
Date d = new Date();
System.out.println(d); // Tue Jul 17 17:17:57 CST 2018可以使用 SimpleDateFormat 来对日期时间进行格式化，可以将日期转换为指定格式的文本，也可将文本转换为日期。
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String timeNow = sdf.format(d);
System.out.println(timeNow); // 2018-07-17 17:22:47使用 parse() 方法将文本转换为日期
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String str = "2014-6-1 21:05:36";
Date date1 = null;
try {
date1 = sdf1.parse(str); // 需要用try-catch包围，因为可能会抛出错误
} catch (ParseException e) {
e.printStackTrace();
}
System.out.println(date1);Calendar
Date 类最主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用 Calendar 类进行时间和日期的处理。
java.util.Calendar 类是一个抽象类，可以通过调用 getInstance() 静态方法获取一个 Calendar 对象，此对象已由当前日期时间初始化，即默认代表当前时间，如 Calendar c = Calendar.getInstance();
public static void main(String[] args) {
// 创建Calendar对象
Calendar c = new Calendar.getInstance();
// 将Calendar对象转换为Date对象
Date date = c.getTime()
// 创建SimpleDateFormat对象，指定目标格式
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 将日期转换为指定格式的字符串
String now = sdf.format(date);
System.out.println("当前时间：" + now);
}集合框架
作用
- 在类的内部，对数据进行组织；
- 简单而快速地搜索大数量的条目；
- 有的集合接口，提供了一些列排列有序的元素，并且可以在序列中间快速地插入或者删除有关元素；
- 有的集合接口，提供了映射关系，可以通过关键字(key)去快速查找到对应的唯一对象，而这个关键字可以是任意类型。
与数组的区别
- 数组的长度固定，集合长度可变；
- 数组只能通过下表访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象； *
collection
是List、Set和Queue接口的父接口
定义了可用于操作List、Set和Queue的方法（增删改查）
List接口
List是元素有序并且可以重复的集合，被成为序列
List可以精确地控制每个元素的插入位置，或删除某个位置元素
动态加载类
静态加载
静态加载是在编译的时候就加载的，用new的都是静态加载
动态加载
运行时加载
try {
Class c = Class.forName(args[0]) // args[0]运行时带入的第一个参数，这里填需要加载的类名
}
catch (Exception e) {
e.printStackTrace();
}