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空指针异常

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

什么时候使用数组呢?

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

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

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

 



Breakcontinue的区别:

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关键字:

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

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

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

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

为什么要用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();

 








相关文章
相关标签/搜索