Loading... # 1. 概述 ## 计算机语言简史 主要阶段 1. 机器语言(打孔机) 2. 低级语言(汇编) 3. 高级语言(Java) ## Java发展简史 ## Java语言特性 简单 面向对象 **可移植性**(一次编译,到处执行) 健壮性(自动垃圾回收机制) 多线程 ## Java的加载与执行 编译阶段 ``` graph TB 源文件-->字节码文件 ``` 运行阶段 ``` graph TB 字节码文件-->类装载器 类装载器-->JVM JVM-->操作系统 操作系统-->硬件平台 ``` # 2. Java语言基础 ## 标识符 可以标识类名、变量名、接口名和方法名 1. 命名规则 1. 标识符有 **数字、字母、下划线和美元符**构成 2. 必须以 **字母、下划线、或美元符** 开头 2. 关键词不能作为标识符 3. 标识符区分大小写 4. 标识符理论上没有长度限制 ## 关键字 都是 *小写* | class | extends | implements | interface | import | | ------------ | --------- | :--------- | ---------- | ------- | | package | break | case | continue | default | | do | if | else | for | return | | switch | while | false | true | null | | boolean | byte | char | short | int | | long | float | double | try | catch | | throw | throws | finally | abstract | final | | native | private | protected | public | static | | synchronized | transinet | volatile | instanceof | new | | super | void | assert | enum | goto | | const | | | | | ## 数据类型 基本类型和引用类型,基本类型有 **8** 种,引用类型有 **3** 种 - 基本数据类型 - 数据类型 - 整数型(byte、short、int、long) - 浮点型(float、double) - 字符类型(char)[2B,Unicode] - 布尔型(boolean,只能取值 **true** 和 **false** ,默认 **false**) - 引用数据类型 - 数组 - 类 - 接口 ## 进制换算 ## 字符编码 - ASCII码 采用一个字节编码,主要针对英文编码 a:97 A:65 0:48 - ISO-8859-1 主要为了西欧语言中的字符编码和ASCII兼容 - GBK 主要是汉字编码 - Unicode 统一了全世界上的所有文字编码,有UTF-8、UTF-16、UTF-32。 > 字符如果采用的编码和解码不一致时,会出现乱码。 #### 关于转义字符 | 转义字符 | 作用 | | -------- | ------------- | | \t | 制表符(Tab) | | \n | 换行 | | \\\ | \ | | \\' | ' | | \\" | " | | \u | Unicode码转换 | ## 数据类型 ##### 整数型 byte(1B,-128--127) short/int/long 三种表示方法 - 十进制 - 八进制,0开头 - 十六进制,0x开头 Java语言整数类型默认为int类型,如果要声明生long类型在变量值后加L,如: `long l = 9999999L` > 如果这个整数(字面值)没有超出byte的取值范围,可以直接将这个整数类型赋值给byte类型。 > > 如果这个整数没有超出short的取值范围,可以直接将这个整数类型赋值给short类型。 > > 如果这个整数没有超出char的取值范围,可以直接将这个整数类型赋值给char类型。 ##### 浮点类型 float 4B double 8B 默认为double ##### 布尔类型 只有true/false两个值,没有1和0 主要用在逻辑运算和条件控制语句中 ##### 基本数据类型的转换 - 在Java中基本类型可以互相转换,只有boolean类型不可以 - 转换分为自动转换和强制转换 - 自动转换:容量小的类型会默认转换为容量大的类型: - byte-->short、char-->int-->long-->float-->double - byte、short、char之间做混合运算时不会互相转换,首先转换成 int - 强制转换: - 将容量大的类型转换成容量小的类型,需要进行强制转换 - 注意:只要不超出范围可以将整数值直接赋值给byte、short、char - 在多种类型混合运算时,会都先转换为最大容量的类型再进行运算。 ## 运算符 ##### 算术运算符 `+` 求和 `-` 相减 `*` 相乘 `/` 相除 ` ++` 自加: > ++ 如果出现在变量后面,先赋值再自加 > > ++ 如果出现在变量前面,先自加再赋值 `--` 自减: `%` 取模 ##### 关系运算符 `<` `<=` `>=` `==` `!=` ##### 布尔运算符 `&&` `||` `&` `|` `!` `^` ##### 位运算符 `& ` 按位与 `|` 按位或 `^` 按位异或 `~` 按位非 `>>` 右移 `>>>` 右移,左边空出来的以0填充 `<<` 左移 ##### 赋值类运算符 `=` `+=` `-=` `*=` `/=` `%=` ##### 字符串连接运算符 `+` > +两边只要都是数字类型,一定是加法运算 > > 任意一端只要是字符串类型,一定是字符串连接 ##### 条件运算符 `?:` > 语法:boolean表达式?A:B > > boolean为true,表达式结果为A,否则为B ##### 其他运算符 `instanceof` `new ` ### 控制语句 java控制语句分为7种: - 控制选择结构语句 - if、if else - switch > 语法: > > ```java > switch(int){ > case int: > java; > java; > break; > case int: > java; > java; > break; > default: > java; > } > ``` - 控制循环结构语句 - for - while - do while - 改变控制语句顺序 - break - continue #### 方法(method)初步 方法:代码片段,可以重复利用 语法: ```java [修饰符列表] 方法的返回值类型 方法名(方法的形参列表){ javacode; } ``` > 修饰符列表是可选的 > > 返回值类型可以是java语言中的任何一种数据类型,如果没有返回值,返回值写:void > > 方法名只要是合法的标识符即可 #### 方法重载 **同一个类**中**方法名**相同,**参数列表(类型、个数、顺序)不同**发生重载。 如果参数列表相同,则编译不通过。 > 方法的重载与方法的返回值类型、修饰符无关,只与参数列表有关。 方法的执行原理: > 方法在调用时,才会给该方法在内存中分配空间。 > > 如果这个方法只是定义没有调用,则不会再内存中分配空间。 > > 方法调用时在“栈”中分配空间 > > 方法调用其实就是“入栈” > > 方法结束就是“出栈” # 3. 面向对象 面向对象的三大特性: - **封装** - **继承** - **多态** 面向对象编程可分为三个阶段: - OOA 面向对象分析 - OOD 面向对象设计 - OOP 面向对象编程 ### 类的定义 ```java 类修饰符 class 类名 extends 父对象名称 implements 接口名称{ 属性和方法 } ``` 示例: ```java // Student.java public class Student{ //属性 int id; // 成员变量是对象级别的,必须先有对象级别才能访问 String name; boolean sex; int age; String addr; //方法 } ``` ### 对象的创建和使用 ```java // 1. 创建对象 // stu是一个局部变量(栈),这个局部变量是Student类型,也就是一个引用类型,存储实例对象的内存地址 Student stu = new Student(); // Java中所有new出来的的数据统一存储在堆中,程序员无法对堆进行操作,只能通过内存地址间接操作 // 实例对象的成员变量是对象相关的,成员变量在堆中的对象里存储 // 成员变量如果没有手动赋值,系统默认赋值 // 所用引用类型默认: null // 2. 使用对象 // 访问成员变量,必须使用 引用.变量 // name是成员变量,对象相关,必须先有对象才能访问,必须使用引用 System.out.println(stu.name); // 赋值 stu.name = "zhansan"; ``` ### 封装性 面向对象的封装性是指: 1. 属性私有化 2. 对外提供公开的接口 ```java //Customer.java public class Customer{ // 属性 private int age; // private修饰的数据只能在本类中使用 // 对外提供公开方法 // setter public void setAge(int age){ // 安全控制 if(age < 0 || age > 100){ return; }else{ this.age = age; } } // getter public int getAge(){ // 成员方法 return age; } } //OOTest02 import Customer pubilc class OOTest02{ public static void main(String[] args){ // 创建 Customer c = new Customer; // 读取 System.out.println(c.getAge()); // 赋值 c.setAge(10); // 读取 System.out.println(c.getAge()) } } ``` ### 构造函数(构造方法、构造器) 构造方法: ```java [修饰符] 类名(形参列表){ 方法体; } // 如果一个类没有提供任何构造方法,系统默认提供无参数构造方法; // 如果一个类提供了构造方法,系统不会提供任何构造方法; // 调用 new 类名(实参); //在堆中开辟空间存储对象 ``` 1. 无返回值类型 2. 构造方法作用 - 创建对象 - 初始化成员变量 ```java // User.java public class User{ int age; boolean sex; public User(){ } public User(int age){ this.age = age; } public User(int age,boolean sex){ this.age = age; this.sex = sex; } } // OOTest03.java public class ConstructorTest01{ public static void main(String[] args){ User user1 = new User(12,true); User user2 = new User(); User user3 = new User(13); } } ``` ### Java内存的主要划分 - 堆区:存放new出来的对象,此对象由垃圾回收器收集,垃圾收集器针对的就是堆区(如果堆中的对象没有更多引用指向,将被回收) - 栈区:每调用一个方法,会创建一个栈帧,存放局部变量 - 方法区:类的所有信息,包括所有的方法,静态变量,常量 ```java public class OOTest03{ public static void main(String[] args){ // u1 是引用 指向User对象 User u1 = new User(); // User对象变成了垃圾 u1 = null; System.out.println(ul.name); //java.lang.NullPointerException(空指针异常) Star s = new Star(); s = null; s.print(); // java.lang.NullPointerException(空指针异常) } } ``` ### 参数传递 程序在执行过程中,参数的传递问题: ``` 1. 传递的数据是基本数据类型 2. 传递的数据是引用数据类型 ``` > 2传递的是内存地址,修改会改变 ### this关键字 任何对象都存在this变量(引用类型),指向自身(内存地址) ```java public class ThisTest01{ public static void main(String[] args){ MyDate t1 = new MyDate(2008,8,8); MyDate t2 = new MyDate(2012,12,20); } } class MyDate{ int year; int month; int day; // ! 通过一个构造方法调用另一个构造方法 MyDate(){ this(1970,1,1); // 必须出现在第一行 } // this 能用在构造方法中 // this 可用来区分成员变量和局部变量 MyDate(int year,int month,int day){ this.year = year; this.month =month; this.day = day; } // this 能用在成员方法中代表当前对象,可省略 public void getMyDate(){ return this.year+"-"+this.month+"-"+this.day; } // this 不能用在静态方法中 } ``` ### static关键字 static修饰的变量和方法不是成员变量 1. static修饰的变量叫做**静态变量** 2. static修饰的方法叫做**静态方法** 3. static还可以定义静态语句块 ```java public class StaticTest01{ // 静态语句块 // 类加载时就会执行,并且只执行一次,自上而下的顺序执行 static{ System.out.println("1"); } static{ System.out.println("2"); } } ``` #### 关于实例语句块 每次调用 **构造方法之前** 都会执行一次 执行顺序自上而下 ```java public class StaticTest02{ // 静态语句块 static{ sout("A"); } static{ sout("1"); } // 实例语句块 { sout("3"); } StaticTest02(){ sout("构造函数执行"); } public static void main(String[] args){ new StaticTest02(); } } ``` #### 静态方法 静态方法为**static**关键字修饰的方法 工具类中的大部分方法都是静态方法 静态方法不需要创建对象就可以使用 ```java public class StaticTest02{ // 引用.函数名 public void m1(){ } // 类名.函数名 or 引用.函数名 // 不能直接访问非静态数据 // 不能使用this public static void m2(){ } public static void main(String[] args){ StaticTest02 st = new StaticTest02(); st.m1(); // static函数中调用static函数 m2(); // 使用引用调用static函数,运行时仍然使用 // StaticTest02. 的方式访问 st.m2(); // 空的引用去访问成员的时候回出现空指针异常 // m2 方法不是成员而是静态的 // 所以即使引用是空的,也不会报空指针异常 st = null; st.m2(); } } ``` #### 静态变量 类共有的属性设置为静态变量 > 成员变量:在创建java对象的时候初始化 > > 静态变量:在类加载的阶段赋值,并且只赋值一次 ```java 类{ 成员变量 成员函数 静态方法 静态函数 实例代码块 静态代码块 构造函数 this } ``` 变量分类: - 局部变量 - 成员变量(实例变量、非静态变量) - 静态变量(存放在方法区) > 成员变量在创建对象时初始化,并且存储在堆中的每一个对象中 > > 静态变量,被存储在方法区,所有同类java对象共享一份 > > 所有静态变量是类级别的 #### 关于代码顺序 ```java public class Test{ static int i = 100; // 静态代码块 static{ System.out.println(i); } public static void main(String[] args){ } } ``` ### 单例模式 > `==` 可比较两个对象 > > 两边如果是基本数据类型,比较的是值 > > 如果是引用类型,比较内存地址 ```java // Singleton.java public class Singleton{ private static Singleton s; // 将构造方法私有化 private Singleton(){ } // 对外提供公开获取Singleton对象的方法 public static Singleton getInstance(){ // 懒汉式单例模式 if(s==null){ s = new Singleton; } // 饿汉式 类加载式创建 // 懒汉式 第一次请求时创建 return s; } } ``` ### 类的继承 作用: - 代码重用 - 实现多态 java 只支持单继承 一个类默认继承Object,Object是java的根类 ```java // Account.java public class Account{ private String actno; double balance; Account(){} Account(String actno,double balance){ this.actno = actno; this.balance = balance; } public void setActno(String actno){ this.actno = actno; } public String getActno(){ return actno; } } // DebitAccount.java /* java语言子类继承父类,会将父类中所有的数据全部继承,包括 私有的.但是在子类中无法直接访问父类中的私有数据,可以间接 (通过父类提供的接口)访问 注意,构造方法无法被继承 */ public class DebitAccount extends Account{ double debit; } ``` #### 方法的覆盖 如果父类中的方法无法满足当前子类的业务要求,需要将父类中的方法重新写一遍. 子类如果重写父类中的方法之后,**子类对象**一定调用的是**重写后**的方法. 发生方法覆盖的条件: > 1. 发生再具有继承关系的两个类之间 > 2. **相同方法名,相同的返回值类型,相同的参数列表** > 3. 重写的方法不能比被重写的方法拥有更低的访问权限 > 4. 重写的方法不能比被重写的方法跑出更宽泛的异常 > 5. 私有的方法不能被覆盖 > 6. 构造方法无法被覆盖 > 7. 静态方法不存在覆盖 > 8. 覆盖指的是成员方法,与成员变量无关 ```java class Animal{ public void move(){ sout("动物在移动"); } } class Cat extends Animal{ // 方法的覆盖 重写 overwrite override public void move(){ sout("猫在移动"); } } class Dog extends Animal{ public void move(){ sout("狗在移动") } } ``` ### 多态 关于java语言中的向上转型和向下转型 1. 向下转型:强制类型转换 2. 向上转型:自动类型转换 两个类之间必须要有继承关系 ```java public class Animal{ public void eat(){ } } public class Cat extends Animal{ public void eat(){ sout("猫吃鱼"); } public void move(){ sout("猫移动") } } public class Test{ public static void main(String[] args){ // 编译阶段只知道a1是一个Animal类型 // 运行时堆中的实际对象时Cat类型 Animal a1 = new Cat(); // 程序在编译阶段a1被看作Animal类型 // 即编译阶段:a1绑定的是Animal的方法(静态绑定) // 程序运行时,堆中的对象实际上是Cat类型,而Cat // 已经重写了eat方法.所以运行时绑定的时Cat中的 // eat方法(动态绑定) a1.eat(); // 猫吃鱼 Animal a2 = new Cat(); // a2.move(); // 报错 // 进行强制类型转换 Cat c1 = (Cat)a2; c1.move(); Animal a3 = new Dog(); Cat c2 = (Cat)a3; //编译通过,运行出错 // java.lang.ClassCastException } } ``` instanceof 返回boolean类型 `引用 instanceof 类型` 在做向下转型时使用该函数做判断 ##### 多态的好处 面向父类编程,方便业务的扩展 1. 使用多态可以使代码之间的耦合性降低 2. 项目的扩展能力增强 ##### 私有的方法无法被覆盖 ```java class A{ private void m1(){ sout("a.m1") } public static void main(String[] args){ A a = new B(); a.m1(); // out: a.m1 } } class B extends A{ public void m1(){ sout("b.m1"); } } ``` ##### 静态方法不存在覆盖 ```java public class Test03(){ public static void main(String[] args){ A a = new B(); a.m1(); // a.m1 } } class A{ public static void m1(){ sout("A.m1"); } } class B{ public static void m1(){ sout("B.m1"); } } ``` #### super 关键字 1. super 不是引用类型,存储的不是内存地址,super指向的不是父类对象 2. super代表的是当前子类对象中的父类型特征 3. 子类和父类中都有某个数据,需要访问父类的数据时使用 4. super可用成员方法中,构造方法中,不能用在静态方法中 ```java // Employee.java public Employee{ String name = "张三"; public void work(){ sout("员工在工作"); } } // Manager.java public Manager{ String name = "李四"; // 重写work方法 public void work(){ sout("经理在工作"); } public void m1(){ work(); // 如果work没有被重写,那么执行的是父.work // 否则,执行覆盖后的work super.work(); // 执行父.work } } ``` super():通过子类的构造方法调用父类的构造方法 一个构造方法第一行如果没有this(...)也没有super(...),则默认调用super() super():的调用只能放在构造函数的第一行,不能共存 可以给当前子对象中的父类型特征赋值,**不会创建父类对象** 所有类都会执行构造方法时都会执行super方法 **单例模式的类型没有子类,无法被继承** #### final关键字 - final修饰的类无法被继承(java.lang.String) - final修饰的方法无法被覆盖 - final修饰的局部变量一旦赋值,无法再改变 - final修饰的成员变量必须**显示的**初始化,不能默认赋值 ```java class A{ // 1 final int i = 100; // 2 final int k; A(){ k=100; } // 3 final int t; //编译不通过 } ``` - final修饰的成员变量一般和static联用(常量标识符大写) ### 抽象类 - 抽象类无法被实例化 ```java public abstact class A{ A(){ } public abstract void m1(); } class B extends A{ B(){ super(); // 父类构造方法虽然调用了,但是并没有创建父类对象 } public void m1(){ } } ``` - 虽然抽象类无法实例化,但是**抽象类也有构造方法**,该方法时给子类创建对象用的 - 抽象类中**可以定义抽象方法** - 抽象类中不一定有抽象方法,但**抽象方法必须出现在抽象类**中 - 一个 **非抽象** 的类继承抽象类,必须将抽象类中的抽象方法覆盖 - 抽象类 抽象方法不能被final修饰 ### 接口 接口也是一种引用类型,等同类: 1. **接口中只能出现:常量 抽象方法** 2. 接口其实是一个特殊的抽象类,完全抽象 3. 接口中**没有构造方法,**无法被实例化 4. **接口和接口之间可以多继承** 5. **一个类可以实现多个接口** 6. **一个非抽象的类实现接口,需要将接口中所有的方法重写** ```java public interface A{ // 常量 public static final String SUCCESS = "success"; public static final double PI = 3.14; // public static final可以省略 byte MAX_VALUE = 127; //常量 // 抽象方法 public abstract void m1(); // public abstact是可以省略的 void m2(); } interface B{ } interface C extends A,B{ } class D implements A,B,C{ ... } ``` implements是实现的意思,是一个关键字 ### Object类 **toString()** : > **返回java对象的字符串表示** > > Object: return classname + hex > > 在现实的开发过程中,Object的toString方法已经不够用 > > **通常重写toString()方法** ```java sout(引用.toString()) == sout(引用) // print方法后括号中如果是一个引用类型,会调用toString ``` **equals()** : > 指示与其他某个对象是否一样 > > Object中equals方法:**如果为引用类型,比较内存地址** > > Object: return this == object **String** 不是基本数据类型,**已经重写equals方法** 所以比较字符串是否一致,使用equals **finalize()** : > 垃圾回收 ### 包和import **软件包机制** > 1. 为了解决类的命名冲突问题,在类名前加包名空间 > 2. 在java中使用 package 语句定义包 > 3. package 语句只能出现在java源文件的第一行 > 4. package定义的格式,通常采用公司域名倒叙方式 > 5. 完整的类名是带包名的 > 6. 带有package语句的java源文件必须这样编译: > > java -d 生成路径 java源文件路径 #### 访问控制权限 | 修饰符 | 类的内部 | 同一个包 | 子类 | 任何地方 | | --------- | -------- | -------- | ---- | -------- | | private | y | n | n | n | | protected | y | y | y | n | | public | y | y | y | y | | default | y | y | n | n | #### 内部类 ##### 静态内部类 > 1. 等同看待静态变量 > 2. 静态内部类可以直接访问外部类的静态数据,无法访问成员 ```java public class OuterClass{ // 静态方法 private static String s1 = "A"; // 成员方法 private String s2 = "B"; private static void m1(){ sout("static.m1 method execute!") } private void m2(){ sout("m2 method execute!") } // 静态内部类 // 可以用访问空去权限修饰符 修饰 static class InnerClass{ // 静态方法 public static void m3(){ sout(s1); // sout(s2); m1(); // m2(); } // 成员方法 public void m4(){ sout(s1) } } public static void main(String[] args){ OuterClass.InnerClass.m3(); InnerClass inner = new OuterClass.Innerclass(); inner.m4(); } } ``` ##### 成员内部类 > 1. 等同看待成员变量 > 2. 成员内部类中不能有静态声明 > 3. 成员内部类可以访问外部类中私有的数据 ```java public class OuterClass{ // 静态方法 private static String s1 = "A"; // 成员方法 private String s2 = "B"; private static void m1(){ sout("static.m1 method execute!") } private void m2(){ sout("m2 method execute!") } // 成员内部类 // 可以用访问空去权限修饰符 修饰 class InnerClass{ // 成员内部类不能有静态方法 // public static void m3(){ // } // 成员方法 public void m4(){ sout(s1) } } public static void main(String[] args){ OuterClass oc = new OuterClass(); InnerClass inner = oc.new InnerClass(); inner.m4(); } } ``` ##### 局部内部类 > 相当于局部变量 > > 重点,局部内部类在访问局部变量是时,局部变量必须使用final修饰 ```java public class OuterClass{ public void m1(){ final int i = 0; // 局部内部类不能访问控制权限修饰符修饰 class InnerClass{ // 内部类不能有静态声明 // public static void m1(){} // 成员方法 public void m1(){ sout(i) } } InnerClass inner = new InnerClass(); inner.m2(); } public static void main(String[] args){ OuterClass oc = new OuterClass(); oc.m1(); } } ``` ##### 匿名内部类 ```java public class Test{ public static void test(CustomerService cs){ cs.logout(); } public static void main(String[] args){ // new CustomerService(){} 就是个匿名内部类 test(new CustomerService(){ public void logout(){ sout("system logout!") } }); // 优点,少定义一个类 // 无法重复使用 } } interface CustomerService{ // 退出系统 void logout(); } ``` # 4. 异常 ## 概念 ```java /* 异常:模拟现实生活中不正常的事件 Java中采用 类 去模拟异常 一个异常类的对象表示一个异常 异常机制:健壮性 */ public class ExceptionTest01{ public static void main(String[] args){ } } ``` ## 分类 异常的继承结构图 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IFOcr14F-1612419381467)(C:\Users\LiTangMM\AppData\Roaming\Typora\typora-user-images\image-20191126100033432.png)] #### 处理异常的方式 1. 声明抛出 > 使用throws处理异常不是真正处理异常而时推卸责任,谁调用抛给谁 ```java import java.io.*; public class ExceptionTest03{ public static void main(String[] args) throws FileNotFoundExcepion{ // 创建文件输入流,读取不存在文件 // 因为FileInputStream这个构造方法在声明的位置生使用了throws FileNotFoundExceptions FileInputStream fis = new FileInputStrean("C:/ab.txt"); } } ``` 2. 捕捉 > catch可以写多个,从上到下,从小到大. exception.printStackTrance(); //打印异常堆栈信息 exception.getMessage(); // ## 自定义异常 编译时异常,直接继承Exception 运行时异常,直接继承RunTimeException ```java public class IllegalNameException extends Exception{ public IllegalNameException(){} public IllegalNameException(String msg){ super(msg); } } public class CustomerService{ public void register(String name) throws IllegalNameException{ if(name.length()<6){ // 创建异常 IllegalNameException e = new IllegelNameException("to short"); // 抛出异常 throw e; } } } public class Test{ public static void main(String[] args){ } } ``` ## 方法覆盖与异常 重写的方法不能比被重写的方法跑出更宽泛的异常 # 5. 数组 > 数组是一种引用类型 > > 数组是一种简单的数据结构 > > 数据是一个容器,可以用来存储其他元素 > > 数组可以存储任何类型,但是同一数组只能存储同类型元素 > > 数组长度不可改变 ```java public class ArrayTest01{ public static coid main(String[] args){ // 静态初始化 int[] a1 = {100,200,150,300}; boolean[] b1 = {true,false,true}; String[] strs = {"AB","CD","EF"}; //动态初始化 int[] a2 = new int[4]; // int[] a1 = {0,0,0,0}; a[0] = 1; a[2] = 3; //数组做参数 m1(new int[]{1,2,3}); m1(a1); } } ``` #### 数组拷贝 System.arraycopy(原数组,开始下标,目标数组,开始下标,拷贝长度) ```java public class Utils{ public static void arrayCopy(Object src,int srcPos,Object dest,int destPos,int length){ for(int i = 0; i < length;i++){ dest[destPos+i] = src[srcPos+i] } } } ``` #### 二维数组 二维数组的每一个元素都是一位数组. ```java public class ArrayTest09{ public static coid main(String[] args){ // 静态化初始二维数组 int[][] a = { {1,2,3}, {45,34}, {0}, {10,23,85,99} }; // 动态初始化 int[][] b = new int[3][4]; } } ``` #### Arrays工具类 java.util.Arrays Arrays.sort():排序 Arrays.binarySearch():二分查找 Arrays.copyof(value,length):从头开始拷贝指定长度 Arrays.copyOfRange(value,start,end):拷贝指定范围 #### 接受用户输入 java.util.Scanner ```java public KeyInput{ public static void main(String[] args){ Scanner s = new Scanner(System.in); String userInput = s.next(); } } ``` # 6. 常用类 CharSequence 是一个接口,String,StringBuffer,StringBuilder实现了它 #### String 重要方法: ```java public int length() {} // 字符串长度 public boolean isEmpty() {} // 字符是否为空 public char charAt(int index) {} // 索引为index的字符 public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {} // 拷贝字符数组 public String[] split(String regex, int limit) {} // 分割字符串 public static String join(CharSequence delimiter, CharSequence... elements) {} // 第一个参数为连接符,第二个为多个CharSequence对象 public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) {} // 第一个为连接符,第二个CharSequence集合 public String toLowerCase() {} // 小写 public String toUpperCase() {} // 小写 public String trim() {} // 去除左右空格 public String toString() {} // return this public char[] toCharArray() {} // return value public static String format(String format, Object... args) { return new Formatter().format(format, args).toString(); } // 使用args代替format的占位符 public boolean startsWith(String prefix, int toffset) {} //判断前缀 public boolean startsWith(String prefix) {} public boolean endsWith(String suffix) {} // 判断后缀 // 正则表达式: public boolean matches(String regex) {} public boolean contains(CharSequence s) {} // 是否包含 public String replaceFirst(String regex, String replacement) {} public String replaceAll(String regex, String replacement) {} ``` ```java public final class String{ // 主要属性 private final char value[]; private int hash; // 构造方法 public String() {} public String(String original) {} public String(char value[]) {} public String(char value[], int offset, int count) {} public String(int[] codePoints, int offset, ins count) {} @Deprecated public String(byte ascii[], int hibyte, int offset, int count) {} public String(byte ascii[], int hibyte) {} public String(byte bytes[], int offset, int length, String charsetName) {} public String(byte bytes[], int offset, int length, Charset charset) {} public String(byte bytes[], String charsetName) {} public String(byte bytes[], Charset charset) {} public String(byte bytes[], int offset, int length) {} public String(byte bytes[]) {} public String(StringBuffer buffer) {} public String(StringBuilder builder) {} String(char[] value, boolean share) {} // 方法 public int length() {} // 字符串长度 public boolean isEmpty() {} // 字符是否为空 public char charAt(int index) {} // 索引为index的字符 public int codePointAt(int index) {} public int codePointBefore(int index) {} public int codePointCount(int beginIndex, int endIndex) {} public int offsetByCodePoints(int index, int codePointOffset) {} public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {} // 拷贝字符数组 public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {} public byte[] getBytes(String charsetName) {} // 字符转编码byte public byte[] getBytes(Charset charset) {} public byte[] getBytes() {} public boolean equals(Object anObject) {} // 与(String)anObject比较是否相等 public boolean contentEquals(StringBuffer sb) {} public boolean contentEquals(CharSequence cs) {} // 与 StringBuffer, StringBuilder比较 public boolean equalsIgnoreCase(String anotherString) {} //忽视大小写比较 public int compareTo(String anotherString) {} // 比较大小 // 1. 逐字比较,不同则返回字相减 2. 否则返回长度差值 public int compareToIgnoreCase(String str) {} // 忽视大小写比较 public boolean regionMatches(int toffset, String other, int ooffset, int len) {} public boolean startsWith(String prefix, int toffset) {} //判断前缀 public boolean startsWith(String prefix) {} public boolean endsWith(String suffix) {} // 判断后缀 public int hashCode() {} //计算hash值 public int indexOf(int ch, int fromIndex) {} // 第fromIndex个ch的索引 public int lastIndexOf(int ch) {} // 最后一个ch的索引 public int indexOf(String str, int fromIndex) {} //第fromIndex个str的索引 public int lastIndexOf(String str) {} //最后一个str的索引 public String substring(int beginIndex, int endIndex) {} //子字符串 public CharSequence subSequence(int beginIndex, int endIndex) {} //子字符序列 public String concat(String str) {} // 添加后缀 public String replace(char oldChar, char newChar) {} // 将所有oldChar替换为 newChar public boolean matches(String regex) {} // 正则表达式 public boolean contains(CharSequence s) {} // 是否包含 public String replaceFirst(String regex, String replacement) {} public String replaceAll(String regex, String replacement) {} public String replace(CharSequence target,CharSequence replacement) {} public String[] split(String regex, int limit) {} // 分割字符串 public static String join(CharSequence delimiter, CharSequence... elements) {} // 第一个参数为连接符,第二个为多个CharSequence对象 public static String join(CharSequence delimiter, Iterable<? extends CharSequence> elements) {} // 第一个为连接符,第二个CharSequence集合 public String toLowerCase() {} // 小写 public String toUpperCase() {} // 小写 public String trim() {} // 去除左右空格 public String toString() {} // return this public char[] toCharArray() {} // return value public static String format(String format, Object... args) { return new Formatter().format(format, args).toString(); } // 使用args代替format的占位符 } ``` #### StringBuilder 线程不安全的;无cache #### StringBuffer 线程安全的,cache保存最后一次输出的String 重要方法: ```java public StringBuffer(String str) {} public synchronized char charAt(int index) {} //获取索引位置的Char public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,int dstBegin) {} // 复制字符数组 public synchronized void setCharAt(int index, char ch) {} //设置指定索引的char public synchronized StringBuffer append(String str) {} public synchronized StringBuffer delete(int start, int end) {} public synchronized StringBuffer deleteCharAt(int index) {} public synchronized StringBuffer replace(int start, int end, String str) {} public synchronized String substring(int start, int end) {} public int indexOf(String str) {} public synchronized StringBuffer reverse() {} // 翻转 // 将value输出为String,并将结果拷贝到Cache public synchronized String toString() {} ``` ```java abstract class AbstractStringBuilder { char[] value; int count; // value实际长度 } // StringBuffer.java public final class StringBuffer extends AbstractStringBuilder { // 主要属性 // 每次修改StringBuffer都会清除Cache,存储最后一次toString结果 private transient char[] toStringCache; // 构造方法 public StringBuffer(){} public StringBuffer(int capacity) {} public StringBuffer(String str) {} public StringBuffer(CharSequence seq) {} // 方法 public synchronized int length() {} //retrun count public synchronized int capacity() {} //return value.length public synchronized void ensureCapacity(int minimumCapacity) {} public synchronized void trimToSize() {} public synchronized void setLength(int newLength) {} //设置长度 public synchronized char charAt(int index) {} //获取索引位置的Char public synchronized int codePointAt(int index) {} //获取索引位置的编码值 public synchronized int codePointBefore(int index) {} public synchronized int codePointCount(int beginIndex, int endIndex) {} public synchronized int offsetByCodePoints(int index, int codePointOffset) {} public synchronized void getChars(int srcBegin, int srcEnd, char[] dst,int dstBegin) {} // 复制字符数组 public synchronized void setCharAt(int index, char ch) {} //设置指定索引的char // append public synchronized StringBuffer append(Object obj) {} public synchronized StringBuffer append(String str) {} public synchronized StringBuffer append(StringBuffer sb) {} public synchronized StringBuffer append(CharSequence s) {} public synchronized StringBuffer append(CharSequence s, int start, int end) {} public synchronized StringBuffer append(char[] str) {} public synchronized StringBuffer append(char[] str, int offset, int len) {} public synchronized StringBuffer append(boolean b) {} public synchronized StringBuffer append(char c) {} public synchronized StringBuffer append(int i) {} public synchronized StringBuffer appendCodePoint(int codePoint) {} public synchronized StringBuffer append(long lng) {} public synchronized StringBuffer append(float f) {} public synchronized StringBuffer append(double d) {} // delete public synchronized StringBuffer delete(int start, int end) {} public synchronized StringBuffer deleteCharAt(int index) {} // replace public synchronized StringBuffer replace(int start, int end, String str) {} // sub public synchronized String substring(int start) {} public synchronized CharSequence subSequence(int start, int end) {} public synchronized String substring(int start, int end) {} // insert public synchronized StringBuffer insert(int index, char[] str, int offset, int len) {} public synchronized StringBuffer insert(int offset, Object obj) {} public synchronized StringBuffer insert(int offset, String str) {} public synchronized StringBuffer insert(int offset, char[] str) {} public StringBuffer insert(int dstOffset, CharSequence s) {} public synchronized StringBuffer insert(int dstOffset, CharSequence s,int start, int end) {} public StringBuffer insert(int offset, boolean b) {} public synchronized StringBuffer insert(int offset, char c) {} public StringBuffer insert(int offset, int i) {} public StringBuffer insert(int offset, long l) {} public StringBuffer insert(int offset, float f) {} public StringBuffer insert(int offset, double d) {} // 查找str位置 public int indexOf(String str) {} public synchronized int indexOf(String str, int fromIndex) {} public int lastIndexOf(String str) {} public synchronized int lastIndexOf(String str, int fromIndex) {} public synchronized StringBuffer reverse() {} // 翻转 // 将value输出为String,并将结果拷贝到Cache public synchronized String toString() {} } ``` #### 基础类型对应的8个包装类 | 基本数据类型 | 包装类型 | | ------------ | -------------------- | | byte | java.lang.Byte; | | short | java.lang.Short; | | int | java.lang.Integer; | | long | java.lang.long; | | float | java.lang.Float; | | double | java.lang.Double; | | boolean | java.lang.Boolean; | | char | java.lang.Character; | 基本数据类型--包装-->引用类型 重要方法: ```java public final class Integer{ static Integer cache[]; // 常量池 static MAX_VALUE; static MIN_VALUE; static int paseInt(String s); // 数字字符转数字 static String toBinaryString(int i); static String toHexString(int i); static String toOctalString(int i); static String toString(int i); // 装箱 static Integer valueOf(int i); static Integer valueOf(String s); public int intValue(); // 拆箱 public String toString(); } // 自动装箱拆箱 after jdk1.5 pubic class test{ public static void main(String[] args){ Integet i1 = 10; int i2 = i1; } } ``` 1. 自动装箱和自动拆箱是编译特性,与运行无关 2. Integet类型比较是否相等不能使用 ==,Interger已经重写了Object中的equals方法. 3. 注意以下程序: ```java public class Test{ // 如果数据在(-128~127)之间,java中引用了一个"整形常量池",在方法区中 public static void main(String[] args){ Integer i3 = 128; // 不会创建对象,直接从池中拿 Integer i4 = 128; // i3 != i4 Integer i5 = 127; Integer i6 = 127; // i5 == i6 Integer i7 = -128; Integer i8 = -128; // i7 != i8 Integer i9 = -129; Integer i10 = -129; // i9 != i10 } } ``` #### 日期 ```java public class DateTest{ import java.util.Date; import java.text.SimpleDateFormat; import java.util.Calendar; public static void main(String[] args){ // 获取系统当前时间 Date nowTime = new Date(); long nowTimeSS = System.currentTimeMillis(); //获取自 1970.1.1 00:00:00:000 到当前毫秒数,1000ms = 1s // 格式化日期 // Date--> String // Y:year M:month d:day H:hour m:month s:s S:ms SimpleDateFormat sdf = new SimpleDateFormat('yyyy.mm.dd HH:mm:ss SSS'); String strTime = sdf.format(nowTime); // 获取特定日期 String strTime = "2008.08.08 08:08:08 999"; SimpleDateFormat sdf = new SimpleDateFormat('yyyy.mm.dd HH:mm:ss SSS'); Date time = sdf.parse(strTime); // 需要异常处理 // 日历 // 获取系统当前一个日历 Calendar c = Calendar.getInstance(); // 查看星期,月份,日期 int i1 = c.get(Calendar.DAY_OF_WEEK); int i2 = c.get(Calendar.DAY_OF_MONTH); // 指定日历 c.setTime(new SimpleDateFormat('').parse('')) } } ``` #### 数字类 ```java // 关于数字格式化 // java.text.DecimalFromat; /* # 任意数字 , 千分位 . 小数点 0 不够补0 */ import java.text.DecimalFormat; public class NumberTest{ public static void main(String[] args){ DecimalFormat df1 = new DecimalFormat("###,###"); String num1 = df1.format(1234567); // "1,234,567"; DecimalFormat df2 = new DecimalFormat("###,###.##"); String num2 = df2.format(1234567.123); //"1,234,567.12" DecimalFormat df2 = new DecimalFormat("###,###.0000"); String num2 = df2.format(1234567.123); //"1,234,567.1230" } } ``` #### 随机类 ```java // 生成随机数 public class RandomTest{ public static void main(String[] args){ // 创建一个新的随机数生成器 Random random = new Random(); // int int i = r.nextInt(101); //[0-100] } } ``` #### enum ```java // 定义一个枚举类型 enum Result{ // 成功和失败 // 规范要求 : 大写 SUCCESS,FAIL } enum Season{ SPRING,SUMMER,AUTUMN,WINTER } ``` --- 转载至CSDN博主:[[李唐敏民](https://blog.csdn.net/qq_39041210 "李唐敏民")] --- 最后修改:2021 年 02 月 18 日 © 允许规范转载 打赏 赞赏作者 支付宝微信 赞 如果觉得我的文章对你有用,请随意赞赏