JAVA基础

二分查找(折半查找) 针对数组有序的情况(千万不要先排序，在查找) public static int binarySearch(int[] arr,int value) { int min = 0; int max = arr.length-1; int mid = (min+max)/2; while(arr[mid] != value) { if(arr[mid] > value) { max = mid - 1; }else if(arr[mid] < value) { min = mid + 1; } if(min > max) { return -1; } mid = (min+max)/2; } return mid; }

x 字符 x。举例：'a'表示字符a \\ 反斜线字符。 \n 新行（换行）符 ('\u000A')  \r 回车符 ('\u000D')

[abc] a、b 或 c（简单类）  [^abc] 任何字符，除了 a、b 或 c（否定）  [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围）  [0-9] 0到9的字符都包括

预定义字符类 . 任何字符。我的就是.字符本身，怎么表示呢? \. \d 数字：[0-9] \w 单词字符：[a-zA-Z_0-9] 在正则表达式里面组成单词的东西必须有这些东西组成

^ 行的开头  $ 行的结尾  \b 单词边界 就是不是单词字符的地方。 举例：hello world?haha;xixi

X? X，一次或一次也没有 X* X，零次或多次 X+ X，一次或多次 X{n} X，恰好 n 次  X{n,} X，至少 n 次  X{n,m} X，至少 n 次，但是不超过 m 次 

DateFormat针对日期进行格式化和针对字符串进行解析的类，但是是抽象类，所以使用其子类SimpleDateFormat

SimpleDateFormat(String pattern) 给定模式 yyyy-MM-dd HH:mm:ss

日期和字符串的转换 a:Date -- String format() b:String -- Date parse()

算一下你来到这个世界多少天?

三种格式

注意事项

案例

三元运算符和if语句第二种格式的关系

格式

执行流程

注意事项

案例

面试题

if语句和switch语句各自的场景

for(初始化语句;判断条件语句;控制条件语句){ 循环体语句; }

执行流程： a:执行初始化语句 b:执行判断条件语句 如果这里是true，就继续 如果这里是false，循环就结束 c:执行循环体语句 d:执行控制条件语句 e:回到b

a:输出10次HelloWorld b:输出1-10的数据 c:输出10-1的数据 d:求1-10的和 e:求1-100的和,求1-100的偶数和,求1-100的奇数和 f:求5的阶乘 g:在控制台打印水仙花数 h:统计水仙花个数 i:改进版的回文数 一个五位数 个位 = 万位 十位 = 千位 个位 + 十位 + 千位 + 万位 = 百位 j:统计1-1000之间同时满足如下条件的数据有多少个 x%3==2 x%5==3 x%7==2

a:判断条件语句无论简单还是复杂，结果是boolean类型 b:循环体语句如果是一条，可以省略大括号，但是不建议 c:有分号就没有左大括号，有左大括号就没有分号

while(判断条件语句) { 循环体语句; } 扩展格式： 初始化语句; while(判断条件语句){ 循环体语句; 控制条件语句; } 通过查看这个格式，我们就知道while循环可以和for循环等价转换。

for和while的区别 a:使用上的区别 for语句的那个控制条件变量,在循环结束后不能在使用了。 而while的可以继续使用。 b:理解上的区别 for适合于一个范围的判断 while适合次数不明确的

A:基本格式 do { 循环体语句; }while(判断条件语句); 扩展格式： 初始化语句; do { 循环体语句; 控制条件语句; }while(判断条件语句); 通过查看格式，我们就可以看出其实三种循环的格式可以是统一的。

三种循环的区别 a:do...while循环至少执行一次循环体 b:for和while必须先判断条件是否是true，然后后才能决定是否执行循环体

循环使用的注意事项(死循环) A:一定要注意修改控制条件,否则容易出现死循环。 B:最简单的死循环格式 a:while(true){...} b:for(;;){}

面向对象是基于面向过程的编程思想

面向对象的思想特点 A:是一种更符合我们思考习惯的思想 B:把复杂的事情简单化 C:让我们从执行者变成了指挥者 举例： 买电脑 洗衣服 做饭 ... 万事万物皆对象

把大象装进冰箱(理解) A:面向过程实现 B:面向对象实现 注意：如何让我们的操作更符合面向对象思想呢? A:有哪些类(名词分析法) B:每个类有哪些成员(属性) C:类与类的关系

类与对象 A:现实世界的事物 属性 事物的基本描述 行为 事物的功能 B:Java语言中最基本的单位是类。所以，我们要用类来体现事物 C:类 成员变量 事物属性 成员方法 事物行为 D:类：是一组相关的属性和行为的集合。是一个抽象的概念。  对象：是该类事物的具体存在，是一个具体的实例。(对象)   举例： 学生：类 班长：对象 汽车图纸:类 汽车:对象

(1)标准的手机类的定义和测试 (2)Demo类有求和方法，Test类进行测试。 什么时候定义成员变量? 当该变量是用来描述一个类的时候。 (3)长方形案例 (4)员工案例 (5)MyMath案例(自己提供加减乘除并测试)

类的定义

使用类的内容

特征

A:成员变量和局部变量的区别(理解) (1)在类中的位置不同 成员变量：类中方法外 局部变量：方法定义中或者方法声明上(参数列表) (2)在内存中的位置不同 成员变量：在堆中 局部变量：在栈中 (3)生命周期不同 成员变量：随着对象的创建而存在，随着对象的消失而消失 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 (4)初始化值不同 成员变量：有默认值 局部变量：没有默认值，必须定义，赋值，然后才能使用 B:类作为形式参数(方法的参数列表)?(理解) (1)如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。

匿名对象(理解)

封装(理解)

private关键字(掌握)

this关键字(掌握)

用于对对象的数据进行初始化

格式： A:方法名和类名相同 B:没有返回值类型，连void都不能有 C:没有返回值  举例:publie Student(){} 思考题：构造方法中可不可以有return语句呢? 可以。而是我们写成这个样子就OK了：return; 其实，在任何的void类型的方法的最后你都可以写上：return 这样写 没意义;

构造方法的注意事项 A:如果我们没写构造方法，系统将提供一个默认的无参构造方法 B:如果我们给出了构造方法，系统将不再提供默认构造方法 如果这个时候，我们要使用无参构造方法，就必须自己给出。 推荐：永远手动自己给出无参构造方法。

给成员变量赋值的方式 A:setXxx() B:带参构造方法

标准案例 class Student { private String name; private int age; public Student(){} public Student(String name,int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } 测试： class StudentDemo { public static void main(String[] args) { //方式1 Student s1 = new Student(); s1.setName("刘刚"); s1.setAge(27); System.out.println(s1.getName()+"---"+s1.getAge()); //方式2 Student s2 = new Student("老沙",30); System.out.println(s2.getName()+"---"+s2.getAge()); } } 2:代码：Student student = new Student();做了哪些事情?(理解) (1)把Student.class文件加载到内存 (2)在栈内存为student 开辟空间 (3)在堆内存为学生对象申请空间 (4)给学生的成员变量进行默认初始化。 (5)给学生的成员变量进行显示初始化。 (6)通过构造方法给成员变量进行初始化。 (7)对象构造完毕，把地址赋值给student 变量

(1)写一个类 (2)加入文档注释 (3)通过javadoc工具生成即可 javadoc -d 目录 -author -version ArrayTool.java

把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，   这多个类就具备了这些内容。这个关系叫继承。

Java中如何表示继承呢?格式是什么呢? A:用关键字extends表示 B:格式： class 子类名 extends 父类名 {}

继承的好处： A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提

A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。 原则：低耦合，高内聚。 耦合：类与类的关系 内聚：自己完成某件事情的能力 B:打破了封装性

Java中继承的特点 A:Java中类只支持单继承 B:Java中可以多层(重)继承(继承体系)

继承的注意事项： A:子类不能继承父类的私有成员 B:子类不能继承父类的构造方法，但是可以通过super去访问 C:不要为了部分功能而去继承

A:继承体现的是：is a的关系。 B:采用假设法

成员变量

构造方法

成员方法

A:Override和Overload的区别?Overload是否可以改变返回值类型? B:this和super的区别和各自的1作用?  1.方法重写：  在子类中，出现和父类中一模一样的方法声明的现象。  方法重载： 同一个类中，出现的方法名相同，参数列表不同的现象。  2. 方法重载能改变返回值类型，因为它和返回值类型无关。  3.this:代表当前类的对象引用 super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)

A:一个类的初始化过程 B:子父类的构造执行过程 C:分层初始化

A:学生和老师案例 继承前 继承后 B:猫狗案例的分析和实现

同一个对象在不同时刻体现出来的不同状态。(举例:水的状态)

A:有继承或者实现关系。 B:有方法重写。 C:有父类或者父接口引用指向子类对象。(举例:动物 d=new Cat()) 多态的分类： a:具体类多态 class Fu {} class Zi extends Fu {} Fu f = new Zi(); b:抽象类多态 abstract class Fu {} class Zi extends Fu {} Fu f = new Zi(); c:接口多态 interface Fu {} class Zi implements Fu {} Fu f = new Zi();

A:成员变量 编译看左边，运行看左边 B:构造方法 子类的构造都会默认访问父类构造 C:成员方法 编译看左边，运行看右边 D:静态方法 编译看左边，运行看左边

好处

弊端

A:向上转型(Fu f = new Zi()) 从子到父,父类引用指向子类对象 B:向下转型 从父到子,父类引用转子类引用

孔子装爹的案例帮助大家理解多态 多态的练习 A:猫狗案例 B:老师和学生案例

把多个共性的东西提取到一个类中，这是继承的做法。

抽象类的特点 A:抽象类和抽象方法必须用关键字abstract修饰 B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类 C:抽象类不能实例化 D:抽象类的子类 a:是一个抽象类。 b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。

抽象类的成员特点： A:成员变量 有变量，有常量 B:构造方法 有构造方法 C:成员方法 有抽象，有非抽象

抽象类的练习 A:猫狗案例练习 B:老师案例练习 C:学生案例练习 D:员工案例练习

抽象类的几个小问题 A:抽象类有构造方法，不能实例化，那么构造方法有什么用? 用于子类访问父类数据的初始化 B:一个类如果没有抽象方法,却定义为了抽象类，有什么用? 为了不让创建对象 C:abstract不能和哪些关键字共存 a:final 冲突 b:private 冲突 c:static 无意义

 比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，   是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。

接口的特点： A:接口用关键字interface修饰 interface 接口名 {} B:类实现接口用implements修饰 class 类名 implements 接口名 {} C:接口不能实例化 D:接口的实现类 a:是一个抽象类。 b:是一个具体类，这个类必须重写接口中的所有抽象方法。

接口的成员特点： A:成员变量 只能是常量 默认修饰符：public static final B:构造方法 没有构造方法 C:成员方法 只能是抽象的 默认修饰符：public abstract

类与类,类与接口,接口与接口 A:类与类 继承关系，只能单继承，可以多层继承 B:类与接口 实现关系，可以单实现，也可以多实现。 还可以在继承一个类的同时，实现多个接口 C:接口与接口 继承关系，可以单继承，也可以多继承

抽象类和接口的区别 A:成员区别 抽象类 变量,常量;抽象方法,非抽象方法 接口 常量;抽象方法 B:关系区别: 类与类 继承，单继承 类与接口 实现，单实现，多实现 接口 继承，单继承，多继承 C:设计理念不同 抽象类：is a，抽象类中定义的是共性功能。 接口：like a，接口中定义的是扩展功能。

练习： A:猫狗案例，加入跳高功能

形式参数： 类名：需要该类的对象 抽象类名：需要该类的子类对象 接口名：需要该接口的实现类对象

返回值类型： 类名：返回的是该类的对象 抽象类名：返回的是该类的子类对象 接口名：返回的是该接口的实现类的对象

链式编程 对象.方法1().方法2().......方法n(); 这种用法：其实在方法1()调用完毕后，应该一个对象；  方法2()调用完毕后，应该返回一个对象。  方法n()调用完毕后，可能是对象，也可以不是对象。

其实就是文件夹 包的定义(掌握) package 包名; 多级包用.分开。

作用： A:区分同名的类 B:对类进行分类管理 a:按照功能分 b:按照模块分

(4)注意事项：(掌握) A:package语句必须在文件中的第一条有效语句 B:在一个java文件中，只能有一个package C:如果没有package，默认就是无包名

(1)我们多次使用一个带包的类，非常的麻烦，这个时候，Java就提供了一个关键字import。 (2)格式： import 包名...类名; 另一种： import 包名...*;(不建议) (3)package,import,class的顺序 package > import > class

分类： 权限修饰符：private,默认,protected,public 状态修饰符：static,final 抽象修饰符：abstract

常见的类及其组成的修饰 类： 默认,public,final,abstract 常用的：public 成员变量： private,默认,protected,public,static,final 常用的：private 构造方法： private,默认,protected,public 常用的：public 成员方法： private,默认,protected,public,static,final,abstract 常用的：public

另外比较常见的： public static final int X = 10; public static void show() {} public final void show() {} public abstract void show();

把类定义在另一个类的内部， 该类就被称为内部类。

举例：把类B定义在类A中， 类B就被称为内部类。 public class A{ private int num=10; private int static num1 = 20; public void p1(){ /* 外部类不能直接访问内部类的成员 包括变量和方法 */ p();//这是直接访问内部类B的p()方法是错误的 /* 外部类要访问内部类的方法必须创建一个对象 */ new B().p();//这是正确的 } class B{ private int num=20; public void p(){       /*    内部类可以访问外部类的成员    包括方法和变量    */    num = 20;    p1();    /*    如果内部类是非静态的只能访问    外部类非静态成员    */    num1 = 200;    //----------------------end    int num = 30;    //需求是打印30,20,10    /*    这个num是就近原则打印后是30    */    System.out.println(num);//30    /*    20是B的成员变量，因此访问成员变量    必须加this    */    System.out.println(this.num);//20    /* 想要打印10，这个10是A类的成员变量 this这种只能访问谁调用的this就是谁 this一定是当前类 外部类.this这个意思是外部类的this,加了一个定语 我们以前讲过，通过类名访问一定是静态的 但是这个this不是静态的（这是个特例）    */    System.out.println(A.this.num);//10 } } static class B1{ public void p(){ } } private class B2{ public void p(){ } } /*当外面想访问B2的时候 我们是通过外部内定义一个方法 来访问B2，那么外面就可以通过外部类 调用这个方法访问B2了， 这个叫间接访问内部类 */ public void b2Method(){ new B2().p(); } public void method(){ int a = 10;//错误的，必须是常量 final int a = 10;//正确的 class C{    public void p(){        num = 20; /* 局部内部类访问局部变量 这个变量只能是常量 为什么？ 局部变量在栈里面，方法结束后 就立即释放了，但是局部内部类是在堆里面 方法结束后不会马上释放，等待JVM回收 那么这个时候对象无法访问a这个变量，因此需要将 局部变量定义为常量 */ a = 20;    } } class C1{ } class C2{ } /* 局部内部类可以访问外部类的成员 局部内部类的生命周期是方法结束后就 等待被 JVM回收 外面是不能直接用局部内部类的 */ C c = new C(); } } public class ADemo{ public static void main(String []args){ A.B b = new A().new B(); A.B1 b1 = new A.B1(); A a = new A(); a.b2Method(); } }

内部类的访问规则 A:可以直接访问外部类的成员，包括私有 B:外部类要想访问内部类成员，必须创建对象

内部类的分类 A:成员内部类 B:局部内部类

成员内部类 A:private 为了数据的安全性 B:static 为了访问的方便性 成员内部类不是静态的： 外部类名.内部类名 对象名 = new 外部类名.new 内部类名(); 成员内部类是静态的： 外部类名.内部类名 对象名 = new 外部类名.内部类名();

30,20,10 class Outer{ public int num = 10; class Inner{ public int num = 20; public viod show() { int num  = 30; System.out.println(num); System.out.println(this.num); System.out.println(Outer.this.num); } } }

局部内部类 A:局部内部类访问局部变量必须加final修饰。 B:为什么呢? 因为局部变量使用完毕就消失，而堆内存的数据并不会立即消失。 所以，堆内存还是用该变量，而改变量已经没有了。 为了让该值还存在，就加final修饰。 通过反编译工具我们看到了，加入final后，堆内存直接存储的是值，而不是变量名。

匿名内部类(掌握) A:是局部内部类的简化形式 B:前提 存在一个类或者接口 C:格式: new 类名或者接口名() { 重写方法; } D:本质： 其实是继承该类或者实现接口的子类匿名对象 )

匿名内部类在开发中的使用 我们在开发的时候，会看到抽象类，或者接口作为参数。 而这个时候，我们知道实际需要的是一个子类对象。 如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。 interface Person { public abstract void study(); } class PersonDemo { public void method(Person p) { p.study(); } } class PersonTest { public static void main(String[] args) { PersonDemo pd = new PersonDemo(); pd.method(new Person() { public void study() { System.out.println("好好学习，天天向上"); } }); pd.method(        /* method是要接收一个实现了Person接口的对象 new Person(){ }这个整体是一个对象                                           Person{ public void study() { System.out.println("好好学习，天天向上"); } }这是在定义一个类，是没有名字的类 相当于省略了class 没有名字的类 implements 等同于 class 没有名字的类 implements Person{ public void study() { System.out.println("好好学习，天天向上"); } } new Person(){ public void study() { System.out.println("好好学习，天天向上"); } } 等同于 new class 没有名字的类 implements Person{ public void study() { System.out.println("好好学习，天天向上"); } }() */ new Person() { public void study() { System.out.println("好好学习，天天向上"); } } //定义一个类并且实例化 ); } }

匿名内部类的面试题(补齐代码) interface Inter { void show(); } class Outer { //补齐代码 public static Inter method() { return new Inter() { public void show() { System.out.println("HelloWorld"); } }; } } class OuterDemo { public static void main(String[] args) { Outer.method().show(); //"HelloWorld" } }

(1)是最终的意思，可以修饰类，方法，变量。 (2)特点： A:它修饰的类，不能被继承。 B:它修饰的方法，不能被重写。 C:它修饰的变量，是一个常量,只能赋值一次。 (3)面试相关： A:局部变量 a:基本类型 值不能发生改变 b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的 B:初始化时机 a:只能初始化一次。 b:常见的给值 定义的时候。(静态推荐) 构造方法中。

概述

静态的特点

静态的内存图

静态的注意事项

静态变量和成员变量的区别

main方法是静态的

程序出现的不正常的情况。

异常的体系 Throwable |--Error 严重问题，我们不处理。 |--Exception     |--RuntimeException 运行期异常，我们需要修正代码     |--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过

A:JVM的默认处理 把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了。 B:自己处理 a:try...catch...finally 自己编写处理代码,后面的程序可以继续执行 b:throws 把自己处理不了的，在方法上声明，告诉调用者，这里有问题

A:编译期异常和运行期异常的区别? 编译期异常 必须要处理的，否则编译不通过 运行期异常 可以不处理，也可以处理 B:throw和throws是的区别 throw: 在方法体中,后面跟的是异常对象名,并且只能是一个 throw抛出的是一个异常对象，说明这里肯定有一个异常产生了 throws: 在方法声明上,后面跟的是异常的类名,可以是多个 throws是声明方法有异常，是一种可能性，这个异常并不一定会产生 finally关键字及其面试题 A:finally用于释放资源，它的代码永远会执行。特殊情况：在执行到finally之前jvm退出了 B:面试题 a:final,finally,finalize的区别? b:如果在catch里面有return,请问finally还执行吗?如果执行,在return前还是后 会，前。 实际上在中间。这个上课我们讲过 C:异常处理的变形 try...catch...finally try...catch... try...catch...catch... try...catch...catch...fianlly try...finally

自定义异常 继承自Exception或者RuntimeException,只需要提供无参构造和一个带参构造即可

异常的注意实现 A:父的方法有异常抛出,子的重写方法在抛出异常的时候必须要小于等于父的异常  B:父的方法没有异常抛出,子的重写方法不能有异常抛出 C:父的方法抛出多个异常,子的重写方法必须比父少或者小

方法定义中调用方法本身的现象 public void show(){ show(); }

递归的注意事项； A:要有出口，否则就是死递归 B:次数不能过多，否则内存溢出 C:构造方法不能递归使用

递归的案例： A:递归求阶乘 B:兔子问题 C:递归输出指定目录下所有指定后缀名的文件绝对路径 D:递归删除带内容的目录(小心使用)

IO流操作中大部分都是对文件的操作，所以Java就提供了File类供我们来操作文件

构造方法 A:File file = new File("e:\\a.txt"); B:File file = new File("e:\\","a.txt"); C:File file = new File("e:\\");  File file2 = new File(file,"a.txt");

A:创建功能 public boolean createNewFile()创建单个文件  public boolean mkdir()创建单个文件夹  public boolean mkdirs()创建多级文件夹           B:删除功能public boolean delete() C:重命名功能public boolean renameTo(File dest) D:判断功能public boolean isDirectory()是否是文件夹  public boolean isFile()是否是文件  public boolean exists()是否存在文件和文件夹  public boolean canRead()是否文件和文件夹可读  public boolean canWrite()是否文件可写  public boolean isHidden()是否文件和文件夹隐藏 E:获取功能public String getAbsolutePath()获取绝对路径(详细的路径从最外层开始到获取处)   public String getPath()获取路径  public String getName()获取文件名  public long length()获取文件的大小  public long lastModified()获取最后的修改时间 F:高级获取功能 public String [] list() public File[] listFiles() G:过滤器功能  public String[]list(FilenameFilter Filter)  public File[] listFiles(FilenameFilter filter)

案例： A:输出指定目录下指定后缀名的文件名称 a:先获取所有的，在遍历的时候判断，再输出 b:先判断，再获取，最后直接遍历输出即可 B:批量修改文件名称

字节流的抽象基类： InputStream ，OutputStream。

构造方法

成员方法

构造方法

成员方法

字符流的抽象基类： Reader ， Writer

构造方法

成员方法

构造方法

成员方法