Java基础_基础知识

首先，我们先了解一下Java的一些特点：
简单、面向对象、可移植、高性能、分布式、动态性、多线程，安全性、健壮性；

Java的运行环境：Java虚拟机，函数库，运行Java 应用程序和Applet锁必须的文件，

Java运行环境的三项主要功能：
加载代码：由Class  loader完成
代码校验：有bytecode verifier完成

执行代码：有runtime interpreter完成

首先，我们先了解一下Java的一些特点：
简单、面向对象、可移植、高性能、分布式、动态性、多线程，安全性、健壮性；

Java的运行环境：Java虚拟机，函数库，运行Java 应用程序和Applets所必须的文件，
Java运行环境的三项主要功能：
加载代码：由Class  loader完成
代码校验：有bytecode verifier完成
执行代码：有runtime interpreter完成
 
名词解释：
 变量：通过变量来操作存储空间中的数据，变量就指这个存储空间，空间位置是确定的
 ，但是里面放置什么值不确定；
变量可分为：局部变量，成员变量（实例变量），静态变量（类变量 被static修饰），
用static定义，从属于类，生命周期伴随类始终存在 ，从类加载到卸载，如果不初始化，它会自动初始化成该类型的默认初始值；

常量：即初始化不能在改变的值

Java 的数据类型分为两大类:基本数据类型和引用数据类型；

引用数据类型有类（class）、接口（interface）、数组（array）

引用数据类型的大小统一为4个字节，记录的是其应用对象的地址！

Byte(1字节 )、short(2字节)、int(4字节)、long（8字节）

Float(4字节）、double(8自己)

Char(2字节)单引号来表示字符常量（char类型用来表示在unicode编码变中的字符）

Java中只有值传递（方法参数中）重点

局部代码快可以定义局部变量的生命周期

 

异或运算中，当一个数诱惑运算同一个数两次，结果还是这个数本身，如啊a^b^b=a;

数组：

数组定义：数组是相同类型数据的集合，描述的是相同类型的若干个数据按照一定的先后顺序排列组合而成，其中每一个数据称作一个数组的元素，每一个数组元素可以通过一个下标来访问它们；

 

数组特点（四个）：

A.长度固定，一旦被创建它的长度就是不可改变的;

B.其元素类型必须是相同的类型，不允许出现混合类型；

C,数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型；

D,数组变量属于引用类型（对象）,数组也可以看作对象，数组的每一个元素相当于该对象的成员变量，数组本身就是对象，因此数组无论保存原始类型还是其他对象类型，数组本身是在堆中的；

对数组常用的操作：

数组的拷贝：System.arrayCopy(源数组，开始位置，目标数组，粘贴位置，粘贴数量)

数组排序：Arrays.sort（）;

二分法查找：Arrays.binarySearch()

 

1.寄存器；

2.本地方法区

3.方法区

4.栈内存：存储的都是局部变量，而且变量所属的作用域有单结束，该变量就自动释放

5.堆内存：存储的是数组和对象（其实数组就是对象）凡是new建立在堆中

特点：A.每一个实体都有首部地址值；

B.堆内存中的每一个变量都是默认初始值，根据类型的不同而不同；

C.垃圾回收机制

6.数组中常见的异常：

  ArrayIndexOfBoundsExceptioon数组越界异常

NullPointerException空指针异常

数组是常用的容器之一，对数组操作最基本的动作就是存和取，核心思想：就是对角标的操作；

什么时候使用数组呢？

如果数据出现了对应关系，而且对应关系的一方是有序的数字编号，并作为角标使用。

这时我们就会使用到数组；

根据运算的结果作为角标直接去查询数组中对应的元素（查表法）

 

Break和continue的区别：

Break作用范围：break一般在switch语句和循环一句使用

记住：当break语句单独存在时，下面不要定义其他语句，因为执行不到。Break跳出所在的当前循环。

如果出现循环嵌套，break想要跳出指定的循环，可以通过标号来完成

 

Continue作用范围：循环结构；

结束本次循环，继续下次循环；如果continue单独存在时，下面不要有任何语句，因为执行

函数的重载：

1.同一个类

2.同名

3.参数个数不同或者参数类型不同、顺序不同

4.函数重载和返回值类型无关；

Java是严谨性的语言，如果函数出现的调用的不确定性，会编译失败

 

构造函数

构建创建对象时调用的函数。

作用：可以给对象进行初始化。

创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义类指定的构造函数，那么类中的默认构造函数就没有了。（留意）

一般函数和构造函数有什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。只会调用一次

一般函数：对象创建后，需要函数功能时才调用，可以调用多次

多个构造函数在类中是以重载的形式来体现的；

一般函数不能直接调用构造函数。

 

静态代码快：

静态代码快：随着类的加载而执行。

而且只执行一次。

作用：用于给类进行初始化。

一般使用在数据库的连接上；

对上面的知识点进行实例展示：

 

public class StaticCode {    public static void main(String[] args) {        A a;        a = new A("战神");        System.out.println(a.name);    }}class A {    static public String name;    final int sum = 0;    A() {    }    A(String name) {        this.name = name;    }static {        System.out.println("static");    }}/** * 执行结果：static *  战神 */

static的特点

1.static是一个修饰符，用于修饰成员。

2.Static修饰的成员被所有的对象所共享。

3.Static优先于对象存在，因为static的成员随着类的加载就已经存在了。

4.Static修饰的成员多了一种调用方式，就可以直接通过类名直接调用。

5.Static修饰的数据是共享数据，对象中的存储的是特有数据。

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

1.生命周期不同：

成员变量随对象的创建而存在，随着对象的被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2调用方式不同：

成员变量只能被对象调用。

静态变量可以被对象调用，也可以被类名调用。

3，别名不同：

成员变量也称为实例变量；

静态变量称为类变量；

4，数据的存储位置不同：

成员变脸数据存储在堆内存的对象中，所以也叫对象的特有数据

静态变量数据存储的方法去（共享数据区）的静态区，所以也叫做对象的共享数据；

静态使用的注意事项：

1.静态方法只能访问静态成员。

2.静态方法中不可以使用this或者super关键字

3.主函数是静态的

什么时候使用静态？

1.当分析对象中所具备的成员变量的值都是相同时，这时候可以使用static修饰成员变量
2.从简单一点看，函数是否用静态修饰，该函数功能是否有访问到对象中的特有数据 

this关键字：

当成员变量和局部变量重名，可以使用关键字this类区分

This代表当前对象，就是所在函数所属对象的引用

 

注意：只能定义在构造函数的第一行。因为初始化动作要先执行

单例设计模式:

解决的问题：就是可以保证一个类在内存中的对象唯一性。

必须对于多个程序使用同一个配置信息对象岁时，就需要保证该对象的唯一性。

两种方式实现：1,饿汉式；2，懒汉式

 

final关键字：

 

继承弊端：打破了封装性。

final关键字：

1，final是一个修饰符，可以修饰类，方法，变量。

2，final修饰的类不可以被继承。

3，final修饰的方法不可以被覆盖。

4，final修饰的变量是一个常量，只能赋值一次。

为什么要用final修饰变量。其实在程序如果一个数据是固定的，

那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。

而且这个变量名称的值不能变化，所以加上final固定。

写法规范：常量所有字母都大写，多个单词，中间用_连接。

 

内部类：

内部类访问特点：

1，内部类可以直接访问外部类中的成员。

2，外部类要访问内部类，必须建立内部类的对象。

一般用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。

这时就是还有的事物定义成内部类来描述。

内部类能直接访问外部类中成员，是因为内部类持有了外部类的引用，即外部类名.this。

内部类也可以存放在局部位置上，但是内部类在局部位置上只能访问局部中被final

修饰的局部变量。

 

class Outer {    private static int num = 31;    class Inner// 内部类。    {        void show() {            System.out.println("show run..." + num);        }    }    public void method() {        Inner in = new Inner();        in.show();    }}

直接访问外部类中的内部类中的成员。

Outer.Inner in = new Outer().new Inner();

in.show();

如果内部类是静态的。相当于一个外部类

Outer.Inner in = new Outer.Inner();

in.show();

匿名内部类：

匿名内部类，就是内部类的简写格式。

必须有前提：

内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}

通常的使用场景之一：

当函数参数是接口类型时，而且接口中的方法不超过三个。

可以用匿名内部类作为实际参数进行传递

class Outer {    void method() {        Object obj = new Object() {            public void show() {                System.out.println("show run");            }        };        ((Object) obj).show();        // 因为匿名内部类这个子类对象被向上转型为了Object类型。        // 这样就不能在使用子类特有的方法了。    }}

正则表达式：

正则表达式对字符串的常见操作:

 1, 匹配。

 其实使用的就是String类中的matches方法。

 2，切割。

 其实使用的就是String类中的split方法。

 3，替换。

 其实使用的就是String类中的replaceAll()方法。

 4，获取。

将正则规则进行对象的封装。

 Pattern p = Pattern.compile("a*b");

 通过正则对象的matcher方法字符串相关联。获取要对字符串操作的匹配器对象Matcher 

 Matcher m = p.matcher("aaaaab");

 通过Matcher匹配器对象的方法对字符串进行操作。

 boolean b = m.matches();