JavaSE 核心基础知识

知识梳理：

1、基础语句

三个方向——运行机制——命名——选择与循环——数组——方法递归

2、面向对象

面向对象——string——this、static、final与super——代码块——单例模式——内部类——继承、覆写、重载、覆盖

3.面向对象高级

抽象类与接口——多态——异常处理机制——exception与err——throws与throw——四种访问权限

第一章——Java概述

1、三个发展方向

• JAVA SE

Java语言的核心类，如数据库连接、接口定义等

• JAVA ME

包含了J2SE的一部分类，用于消费类电子产品的软件开发，如游戏、通讯等

• JAVA EE

包含J2SE所有的类以及EJB、Servle、JSP、XML和事务控制，也是现在主要的方向

2、Java语言的特点

• 简洁

相对于C++更易于理解，没有指针等概念，

• 可移植

能够同时在Windouws、MacOS、UNIX等平台上运行

• 面向对象

面向过程：注重函数，实现具体功能

面向对象：注重对象，描述具有哪些作用而不是为了解决具体的问题

• 解释型

效率低、执行慢，优点是“一次编写，到处运行”

• 适合分布式计算

例如通过URL访问远程对象

• 安全

在编译阶段就可以发现错误，而不是必须通过运行错误才能暴露出来

• 多线程

处理多线程比较简单，而且功能强大

• 动态

a、可以查询运行时的信息

b、将新代码加到一个正在运行的程序中

3、运行机制与虚拟机

• 虚拟机

指在一台计算机上模拟由软件和硬件组成的虚拟计算机，Java有自己设计的虚拟机JVM。

• 运行机制

a、编译器将.java程序文件编译成.class字节码文件，.class文件是一段包含着虚拟机指令、程序和数据片段的二进制文件，及字节码

b、JVM（解释器）将字节码处理后生成电脑可以直接执行的机器码，在特定的平台上运行

4、Java开发环境搭建

•  用户变量：

JAVA_HOME：用户自定义变量，指定jdk路径

• 系统变量：

PATH：说明执行Java命令的路径

ClassPath：说明类的运行路径，即保存 .class文件的路径，只在运行时起作用

• AVA_HOME

C:\Program Files (x86)\Java\jdk1.8.0_66

• Path

在最前边加入%JAVA_HOME%\jre\bin;%JAVA_HOME%\bin;

%JAVA_HOME%\jre\bin;%JAVA_HOME%\bin;C:\ProgramData\Oracle\Java\javapath;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;

• CLASSPATH

.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar

注意：

解决多个java版本并存的问题

第一步

打开C:\Windows\System32

删除以下三个文件

java.exe 、javaw.exe 、javaws.exe 

第二步

打开C:\Windows\System64

删除以下三个文件

java.exe 、javaw.exe 、javaws.exe 

第三步

打开C:\Program Files (x86)\Common Files\Oracle\Java\javapath

如果存在同样删除

第四步

在更改jdk 的时候，启动idea 会报错，重启idea试一下

5、注释

单行注释：//

多行注释：/* */

文档注释：/**       */

6、标识符命名规则

由任意顺序的大小 写字母、数字、下划线、美元符号组成，但标识符不能以数字开头

---

---

---

---

---

---

 

第三章——基础程序设计

1、数据类型

 

2、数据转换

• 自动转换

任何数据类型遇到String类型的变量或常量之后都向String类型转换

a、转换前后的数据类型兼容

b、转换后的数据类型的表示范围比转换前的类型大

• 强制转换

将大范围的数据类型转换为小范围的数据类型

 

3、运算符

赋值运算符、一元运算符、算术运算符、关系运算符、自增与自减运算符、逻辑运算符、括号运算符、位运算符、三目运算符

4、选择结构

1. if语句
2. if else语句（三目运算符与此功能等价）
3. if...else if...else语句

• switch语句

swtich()变量类型只能是int、short、char、byte和enum类型（JDK 1.7 之后，类型也可以是String了）。

Switch(条件表达式){

case 常量1：

    语句1;

    break;

case 常量2：

    语句2;

    break;

    ...

case 常量n：

    语句n;

    break;

default:

    语句：

    break;    //最后这个break可以省略

}

5、循环结构

可以使用Ctrl+c结束程序的循环

1. while循环
2. do while循环
3. for 循环

• 循环中断

a、break语句可以强迫程序中断循环

b、continue语句可以强迫程序跳出本次循环

---

---

第四章——数组与方法

1、数组

• 静态初始化

数据类型 数组名[]={}

• 动态初始化

数值类型 数组名[]=new 数值类型[]

• 数组排序

Java.util.Arrays.sort()，可以对各个基本数据类型的数组进行排序，包括浮点型、字符型等

• 数组复制

System.arraycopy(原名称,原开始点,目标名称,目标开始点,复制长度)

2、方法

public static 返回值 方法名 （）；

• 方法的重载

方法的重载一定只是在参数的个数或类型不一样，不能通过返回值类型不一样实现重载

• 递归调用

递归调用是一种特殊的调用形式，属于方法的自身调用

• 表达式调用

3、java新特性

• 可变参数

类型固定但个数动态即可以是0个也可以是n个，多用于方法重载，本质上是一个数组，有length属性和有索引[index]

返回值类型 方法名称（类型…参数名称）｛｝

public void eat(int... x);

注意：

a、动态参数列表在方法的参数中只能存在一个

b、必须放在方法参数的末尾如：public void eat(int y,int... x);

c、如public void eat(int... x,int y)因为计算机不知道int...x传递的参数到哪里才是结束

 

• foreach

---

---

---

第五章——面向对象（基础篇）

1、面向对象：

封装：将一类对象的共同特征总结出来构造类的过程

继承：从已有类得到继承信息得到新类的过程

多态：同样的对象引用调用同样的方法但是做了不同的事情

2、String

方法摘要
char	charAt(int index)           返回指定索引处的 char 值。
String	concat(String str)           将指定字符串连接到此字符串的结尾。
boolean	contains(CharSequence s)           当且仅当此字符串包含指定的 char 值序列时，返回 true。
boolean	endsWith(String suffix)           测试此字符串是否以指定的后缀结束。
boolean	equals(Object anObject)           将此字符串与指定的对象比较。
boolean	equalsIgnoreCase(String anotherString)           将此 String 与另一个 String 比较，不考虑大小写。
byte[]	getBytes()           使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
int	hashCode()           返回此字符串的哈希码。
int	indexOf(int ch)           返回指定字符在此字符串中第一次出现处的索引。
int	indexOf(int ch, int fromIndex)           返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
boolean	isEmpty()           当且仅当 length() 为 0 时返回 true。
int	lastIndexOf(int ch)           返回指定字符在此字符串中最后一次出现处的索引。
int	length()           返回此字符串的长度。
String	replace(char oldChar, char newChar)           返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
String[]	split(String regex)           根据给定正则表达式的匹配拆分此字符串。
String	substring(int beginIndex)          截取指定位置到末尾之间的字符串，左边开区间，右边闭区间
char[]	toCharArray()           将此字符串转换为一个新的字符数组。
String	toLowerCase()           使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
String	toString()           返回此对象本身（它已经是一个字符串！）。
String	toUpperCase()           使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
String	trim()           返回字符串的副本，忽略前导空白和尾部空白。

2、this关键字

1. 调用本类属性
2. 调用本类方法
3. 当前对象：哪个对象调用了this所在的类，当前对象就是哪个

3、static关键字

static对象是所有对象共享的

4、代码块

• 静态代码块

使用static声明

• 构造块

写在类中的代码块

• 普通代码块

写在方法或语句中

• 同步代码块

使用Synchronize声明，用于多线程

构造块优先于构造方法执行，而且每次实例化对象时都会执行构造块中的代码，会执行多次

静态代码块优先于主方法执行，而在类中定义的静态代码块会优先于构造块执行，而且不管有多少对象产生，静态代码块只执行一    次

5、单例模式

控制实例化对象的产生

a、使用private声明构造方法，使外部类不能实例化该类

b、实例化对象作为属性封装和共享

c、使用static声明取得实例化对象的方法，达到通过“类名.方法” 来访问方法的目的

6、内部类

可以方便的访问外部类的私有属性

成员内部类访问：Outer.Inner in=new Outer().new Inner()

static内部类访问：Outer.Inner in=new Outer.Inner()

在方法中定义内部类：方法中的参数想要被内部类访问，则参数前加上final

7、匿名内部类：

在接口和抽象类的应用上发展起来的，可以实例化接口和抽象类

new 父类构造器（参数列表）|实现接口（）  
    {  
     //匿名内部类的类体部分  
    }

a、使用匿名内部类时必须继承一个抽象类或实现一个接口，不能实现多个接口

b、匿名内部类中是不能定义构造函数的。

c、匿名内部类中不能存在任何的静态成员变量和静态方法。

d、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

e、匿名内部类不能是抽象的

• 初始化

利用构造代码块为匿名内部类创建一个构造器的效果。

public class OutClass {
    public InnerClass getInnerClass(final int age,final String name){
            new InnerClass() {
            int age_ ;
            String name_;
            //构造代码块完成初始化工作
            {
                if(0 < age && age < 200){
                    age_ = age;
                    name_ = name;
                }
            }
            public String getName() {
                return name_;
            }        
            public int getAge() {
                return age_;
            }
        };
    }   
    public static void main(String[] args) {
        OutClass out = new OutClass();        
        InnerClass inner_1 = out.getInnerClass(201, "chenssy");
        System.out.println(inner_1.getName());        
    }
}

---

第六章——面向对象（高级篇）

1、类的继承

子类对象在实例化前会先默认调用父类的构造方法

2、方法的覆写

方法名称、参数类型及个数与父类完全相同的方法

注意：

子类覆写的方法不能拥有比父类方法更加严格的访问权限

从private变为default不算是方法覆写

class Father{
    private void print() {
        System.out.println("father");
    }
    public void fun() {
        this.print();                                            //2：如果子类复写了print（）方法，那么会调用子类复写过后方法，但此时子类并没有复写该方法，那么会调用父类自身的print（）方法
    }
}
class Son extends Father{
    void print() {
        System.out.println("son");
    }
}
public class Test{
    public static void main(String[] args) {
        new Son().fun();                                        //1：子类找不到fun方法，会继续从父类查找该方法
    }
}
输出：father

 

3、属性的覆盖

如果子类和父类声明了相同名称的属性，则子类会使用本类中的属性

4、super关键字

a、调用父类的构造方法、普通方法和属性

b、调用构造方法时必须放在方法首行（这点与this调用本类构造方法一致）

5、final:意为最终，也可译为完结器

1. final声明的变量即为常量，常量不可以修改
2. final声明的方法不能被子类覆写
3. final声明的类不能有子类

6、抽象类

专门用来当做父类，不支持多继承

1. 抽象类可以没有抽象方法
2. 抽象方法只需声明无需实现
3. 抽象类被继承时，子类必须覆写抽象方法

7、接口

1. 由全局常量与公共抽象方法组成
2. 支持多继承
3. public staitc final与public abstrat可以省略
4. 抽象类可以实现接口
5. 接口不能继承抽象类
6. 一个接口可以多继承其他接口

8、多态

• 方法的重载与覆写
• 对象的多态性

向上转型：父类 父类对象：子类实例

程序会自动完成向上转型

向下转型：子类 子类对象=（子类）父类实例

对象向下转型前，必须首先发生对象向上转型

9、Instanceof

返回boolean值，判断对象是哪个类的实例

10、Object类

方法摘要
protected  Object	clone()           创建并返回此对象的一个副本。
boolean	equals(Object obj)           指示其他某个对象是否与此对象“相等”。
Class<?>	getClass()           返回此 Object 的运行时类。
int	hashCode()           返回该对象的哈希码值。
void	notify()           唤醒在此对象监视器上等待的单个线程。
void	notifyAll()           唤醒在此对象监视器上等待的所有线程。
String	toString()           返回该对象的字符串表示。
void	wait()           在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
void	wait(long timeout)           在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。

11、装箱与拆箱

是java早年设计缺陷，基础类型是数据，不是对象，也不是Object的子类，需要装箱才能和其他Object的子类共用同一个接口

a、把一个基本类型包装成一个类，可以使这个类型具有可以调用的方法。

b、遵循Java向面像对象语言的设计理念。其实Java还不算是很纯的面向对象的语言。真正的面向对象，是没有基本数据类型的。它只有一种类型，就是对象。

c、解决基本类型不可以做泛型参数的问题 。

第七章——异常的捕捉和处理

避免了大量的判断语句来处理异常

1、常用异常类

两者都是Throwable的子类

Exception：程序中出现的问题

Error：JVM的错误，程序无法处理

2、Java异常处理机制

Java中所有捕获范围小的异常必须放在捕获范围大的异常之前

1. 产生异常实例化对象
2. try语句捕捉异常
3. 与catch语句进行匹配

3、throws与throw

a、throws声明的方法表示此方法不处理异常，而交给方法的调用处进行处理异常，而交给调用处处理，不管是否会有异常，在调用处             进行异常处理

b、throw人为的抛出一个异常，抛出时直接抛出异常的实例化对象

4、RunntimeException类

RunntimeException类是Exception类的子类，可以不用try…catch进行处理，交给JVM进行处理

5、自定义异常类

继承Exception类

6、断言

assert boolean 表达式；

a、断言就是肯定某一个结果的返回值是正确的，如果最终此结果的返回值是错误的，会提示错误信息

b、最然断言的返回的是boolean值，但是并不能将其作为条件判断的语句

---

---

---

---

---

---

第八章——包的访问控制权限

1、系统常见包

• java.lang

  基本的包，自动导入

• java.lang.reflect

  反射机制的包

• java.util

  工具包，一些常见的类库、日期操作等都在此包中

• java.sql

  数据库操作包

• java.io

  输入、输出处理

2、静态导入

如果一个类中的方法全部是使用static声明的静态方法，则在导入时就可以使用import static的方式导入

3、访问控制权限

	Private	Default	Protected	public
只用本类内部可访问	√	√	√	√
同一包中的类（包括子类，以及以对象.成员）		√	√	√
其它包中的子类			√	√
其它包中的类				√

 

注意：

主要是默认和protected这两个修饰符，总结起来就是：

    默认的：同一包中的类（包括子类，以及对象.成员），可以访问；
    protected：同一包和其他包的子类，可以访问；

a、可访问指的是能不能通过 ”实例化对象.变量名“的方式访问

b、因为除static声明的变量属于类变量外，其他的都属于实例变量，是属于某个对象的

c、例如：Person p = new Person(); p.age直接访问age变量

 

4、Java命名规则

变量名可以由英文字母、数字、下划线、和美元符号组成，但标识符不能以数字开头