Java语言基础

1.java开发环境：

        1.编译运行过程：

                1,编译期: .java源文件，经过编译生成.calss字节码文件

                2.运行期：JVM加载.class并运行.calss

                        跨平台、一次编程到处使用

1.名词：

        1.JVM：java虚拟机加载.class并运行.calss

        2.JRE：java运行环境,JRE=JVM+java系统类库（小零件）

        3.JDK：java开发工具包 JDK=JRE+编译、运行等命令工具。

2.变量：存数的，代词，指代的就是里面的那个数。

        1.命名：

                1.只能包含字母、数字_和|$符，不能以数字开头。

                2.严格区分大小写、

                3.不能使用关键字.

                4.允许使用汉字，但是不建议，建议“英文的简明知意”，小驼峰命名法。

3.八种基本数据类型：byte short int long float double boolean char

        1. byte：字节型 1个字节 -128--127；

        short：短整型 2个字节

        int： 整型 4个字节

                1.整数直接量默认为int类型，但不能超过范围，，若超范围会发生编译错误。

                2.两个整数相除，结果还是整数，小数位无条件舍弃。

                3.运算时若超范围，则发生溢出。

        long: 长整型 8个字节

                1.长整型直接量需要在数字后面加L或l

                2.运算时有可能出现异常，建议在第一个数字后加L

        float: 单精度浮点型 4个字节

        double：双精度浮点型 8个字节

                1.浮点数直接量默认为double型，若表示float需要在数字后面加F或f；

                2.double和float型数据参与运算时，有可能会发生舍入误差，精确场合不能使用。

        boolean：布尔型 1个字节

        char： 字符型 2个字节

                1.采用Unicode字符集编码格式，一个字符对应一个码。

                表现的形式是字符char，但本质上码int(0---65535之间)

                ASCII码：‘a'--97 ‘A’--65 ‘0’--48

                2.字符型直接量必须放在单引号中，有且仅有一个字符。

                3.特殊符号须通过\来转义。

4.基本类型有小到大依次为：

byte---short---int---long---float---double

        char

        1.隐式类型转换：小类型转大类型。

        2.强制类型转换：大类型到小类型。

        规则：1.整数直接量可以直接赋值给byte，short，char，但不能超范围。

                   2.byte,short,char型数据参与运算时，系统一律自动将其转换为int再运算

        补充：1.小驼峰命名法：第一个单词首字母小写，其余单词首字母大写------变量、方法 。

                    2.大驼峰命名法：所有字母首字母都大写---类。

5.运算符：

        1.算数运算符

                1.算术运算符：+ - * / % ++ --

                ++/--：1.单独使用时，在前在后都一样

                            2.被使用时，在前在后不一样

                                        1.a++的值为a；

                                        2.++a的值为a+1；

        2.关系运算符：< > <= >= == !=

        3.逻辑运算符：&& || !

        4.赋值运算符： = += -= *= /= %=

        5.字符串连接： +

        6.三目运算符：boolean ？数1 ： 数2

6.1.顺序结构。

    2.分支结构：

                1.if结构

                2.if...else结构：

                3.if.....else if

                4.switch....case

                        (1.效率高、结构清晰，但是只能对整数判断。）

                      （2.switch可以作用于 byte short int char String 枚举类型)

3.循环三要素

        1.循环变量的初始化；

        2.循环的条件

        3.循环变量的改变；

        循环结构：1.while 2.do....while 3.for( ; ; ;)

7.数组

        1.是一种数据类型（引用类型）

        2.相同数据类型元素的集合

        3.定义：

                int[] arr = new int[10];

                int[] arr = {1,4};

                int[] arr = new int[]{1,4,7}

                int[] arr;

                arr = new int[]{1,4,7};

        4.访问的是数组中的元素。

                1.通过（数组名.length）可以获取数组的长度（元素的个数）

                2.通过下标/索引来访问数组中的元素。

5.遍历/迭代：从头到尾挨个走个遍

        int[] arr = new int[10];

        for(int i = 0;i<arr.length;i++){

        arr[i] = (int)(Math.random()*100);

        System.out.println(arr[i]);

        补充：     1, \t为水平制表位，固定占8位。

                        2.ArrayIndexOutOfBoundsException数组下标越界异常。

6. 数组的复制：System.arraycopy(a,1,b,2,3);

                        int[] b = Arrays.copyOf(a,6);

                        Arrays.sort();

8.方法：函数、过程

        1.方法

                1.封装一段特定的业务逻辑功能。

                2.尽可能的独立，一个方法只干一件事情。

                3.方法可能被反复多次跳用。

                4.减少代码重复，有利于代码复用，有利于代码维护。

        2.定义方法：五要素

                修饰词 返回值类型 方法名（参数列表）{

                方法体---------具体的业务逻辑功能实现

                }

        3.调用方法；

                1.无返回值：方法名（有参传参）；

                2.有返回值：数据类型 变量= 方法名（有参传参）

        4. 1.return值：结束方法的执行；返回结果给调用方（用在有返回值的方法中）

                return： 1.结束方法的执行--------用在无返回值的方法中。

                补充： 形参：形式参数，定义方法时的参数为形参；

                实参：实际参数，调用方法时的参数为实参。

9.类 对象

        1.类：类别/类型，代表一类个体。

        2.对象：软件中真实存在的单个个体/东西。

        3.类中包含：1.成员变量 2.方法

        4.一个类中可以创建多个对象。

数据类型 引用类型变量 指向 对象

Student s = new Student();

10.重载（overload/overloading）---------更加方便用户的访问。

1.发生在同一类中，方法名相同，参数列表不同。

2.编译器在编译时会根据方法的签名自动绑定方法。

补充：默认值规则

byte，short，int，long，char--------0；

float，double ---------------------0.0；

boolean-------------------------------------false;

引用类型----------------------------------null;

11.构造方法

1.作用：给成员变量赋初始值

2.与类同名，没有返回值类型。

3.在创建对象时自动被调用。

4.若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了构造方法，则不在默认提供

5.构造方法可以重载。

12.this的用法：

1.指代当前对象，哪个对象调用方法它指的就是哪个对象。

2.只能用于方法中，方法中访问成员变量之前默认有个this。

3.this.成员变量名-----------访问成员变量。

this.方法名()---------------调用方法。

this（）---------------------调用构造方法。

补充：1.内存管理：由JVM来管理的

1.堆：new出来的对象（包括成员变量）

2.栈：局部变量（包括方法的参数）

3.方法区--------

4.成员变量：写在类中，方法外-----有默认值。

局部变量：写在方法中--------没有默认值。

13.继承：

1.作用：代码复用。

2.通过extends来实现继承。

3.超类：共有的属性和行为。

派生类：特有的属性和行为。

4.派生类既可以访问自己的，也能访问超类，但是超类不能访问派生类。

5.一个超类可以有多个派生类，一个派生类只、‘能有一个超类--------单一继承。

6.具有传递性。

7.构造派生类之前必须先构造超类

1.在派生类的构造方法中若没有调用超类的构造方法，则默认super()调用超类的无参构造方法。

2.在派生类的构造方法中若自己调用了超类的构造方法，则默认不提供。

super（）调用超类的构造方法，必须位于派生类构造方法的第一条。

8.super的用法：

1.super.成员变量名--------访问超类的成员变量

2.super.方法名（）---------调用超类的方法

3.super（）----------------调用超累的构造方法。

14.向上造型

1.超类的引用指向派生类的对象。

2.能点出来什么，看引用的类型。

15.方法的重写

1.发生在父子类中，方法名相同，参数列表不同。

2.重写方法被调用时，看对象的类型。

3.“两同两小一大”

1.两同： 1.方法名相同 2.参数列表相同

2.两小： 1、派生类方法的返回值类型小于或等于超类方法的（1、void和基本类型时，必须相等。2.引用类型时，小于或等于）

2、派生类方法抛出的异常小于或等于超类方法的

3.一大：

1.派生类方法的访问权限大于或等于超类方法的

16.重写与重载的区别：

1.重写（override）：发生在父子类中，方法名相同，参数列表相同。

2.重载（overload）：发生在同一类中，方法名相同，参数列表不同。

17.1.package和import

1.package：声明包

1.避免类的命名冲突。

2.同包中的类不能同名，但不同包中的类可以同名。

3.类的全程：包名.类名。

4.包名常常用层次结构，建议所有字母小写。

2.import：导入类

1.同包中的类可以直接访问。

不同包中的类不能直接访问，若想访问：

1.先import声明类，在访问类

2.类的全程

2.访问控制修饰符：--------------------保证数据的安全。

1.public：公开的，任何类。

2.private：私有的，本类。

3.protected：受保护的，本类、派生类、同包类。

4.默认的：什么也不写，本类、同包类。

（-类的访问权限只能是public或默认的。

-类中成员的访问权限如上4中都可以。

-访问权限由高到低依次为：public>protected>默认的>private？）

3.final：最终的、不可改变的

1.修饰变量：变量不能被改变。

2.修饰方法：方法不能被重写。

3.修饰类：类不能被继承。

4.static：静态的

1.静态变量：

1.由static修饰

2.属于类，存储在方法区中，只有一份。

3.常常通过类名点来访问。

4.何时用：所有对象所共享的数据（图片、音频、视频等）

2.静态方法：

1.由static修饰。

2.属于类，存储在方法区中，只有一份。

3.常常通过类名点来访问。

4.静态方法中没有隐式this传递，不能直接访问实例成员。

5.何时用：方法的操作与对象无关。

3.静态块：

1.由static修饰。

2.属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块执行一次。

3.何时用：加载/初始化静态资源（图片、音频、视频）

实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份通过引用对象点来访问。

静态变量：由static修饰，属于类的，存储在方法区中，只有一份，通过类名点来访问。

5. 内存管理：由JVM来管理。

1.堆：new出来的对象（包括实例变量）

2.栈：局部变量（包括方法的参数）

3.方法区：.class字节码文件（包括静态变量、所有方法）

6.static final常量：

1.必须声明同时初始化

2.类名打点来访问，不能被改变

3.建议：常量名所有字母都大写，多个单词用_分隔

4.编译器在编译时会将常量直接替换为具体的数，效率高

5.何时用：数据永远不变，并且经常使用。

7.抽象方法：

1.由abstract修饰

2.只有方法的定义，没有具体的实现（连{}都没有）

8.抽象类：

1.由abstrate修饰

2.包含抽象方法的类必须是抽象类

3.抽象类不能被实例化（new对象）

4.抽象类是需要被继承的，派生类：

1.重写所有的抽象方法---------------变不完整为完整

2.也声明为抽象类---------------------

5.抽象类的意义：

1.封装共有的属性和行为。

2.为所有派生类提供统一的类型--------向上造型。

3.可以包含抽象方法，为所有派生类提供统一的入口。

派生类的行为不同，但入口是一致的，同时相当于定义了一个标准（强制重写）

9.成员内部类：

1.类中套类，外面的称为外部类，里面的称为内部类。

2.内部类通常只服务于外部类，对外不具备可见性。

3.内部类对象通常在外部类中创建。

4.内部类中可以直接访问外部类的成员（包括私有的）。

内部类中有个隐式的引用指向了创建他的外部类对象：外部类名.this

匿名内部类：

1.若想创建一个类的对象，并且对象只被创建一次，可以做成匿名内部类。

2.在匿名内部类中默认外面的变量为final的。

10.接口：

1.是一种引用类型。

2.用interface定义。

3.只能包含常量的抽象方法。

4.接口不能被实例化。

5.接口需要被实现/继承的，实现类/派生类。

6.一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现。

7.接口可以继承接口。

11.多态

1.向上造型/自动类型转换：

1.超类型的引用指向派生类的对象。

2.能点出来什么，看引用的类型。

3.能造型成为的数据类型由：超类+所实现的接口。

2.强制类型转换，成功的条件只有如下两种：

1.引用所指向的对象，就是该类型。

2.引用所指向的对象，实现了该接口或继承了该类。

强转若不符合上述条件，则发生ClassCastException类型转换异常。

12.内存管理：由JVM来管理。

1.堆：

1.new出来的对象（包括实例变量）

2.垃圾：没有任何引用所指向的对象。

垃圾回收器（GC）不定时到内存中清扫垃圾，回收过程是透明的。

不一定一发现垃圾就立刻回收，通过调用System.gc()可以建议JVM尽快调度GC回收。

3.实例变量的生命周期：

创建对象时存储在堆中，对象被回收时一并被回收。

4.内存泄漏：不再使用的对象被及时的回收，严重的泄露会导致系统的崩溃。

2.栈：

1.存储正在调用的方法中的局部变量(包括方法的参数)

2.调用方法时，会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量(包括方法的参数)，方法调用结束时，栈帧被自动清除，局部变量一并被清除

3.局部变量的生命周期：

​ 调用方法时存储在栈中，方法调用结束时与栈帧一并被清除

3.方法区：

1.存储.class字节码文件(包括静态变量、所有方法)

2.方法只有一份，通过this来区分具体的访问对象

13.面向对象三大特征：-------------敲黑板、重点之重点

1.封装：

1.类：封装的是对象的属性和行为

2.方法：封装的是具体的业务逻辑功能实现

3.访问控制修饰符：封装的是具体的访问权限，以保护数据的安全

2.继承：

作用：代码复用

超类：所有派生类所共有的属性和行为

接口：部分派生类所共有的属性和行为

派生类：派生类所特有的属性和行为

单一继承、多接口实现，具有传递性

3.多态：

行为多态：所有抽象方法都是多态的(通过方法的重写实现的)

对象多态：所有对象都是多态的(通过向上造型来实现)

向上造型、强制类型转换、instanceof判断

14.String：字符串类型

java.lang.String使用final修饰，不能被继承

java中的String在内存中采用Unicode编码方式，任何一个字符占用两个字节的编码

字符串底层封装的是一个字符数组

字符串一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值------不变对象

15.常量池：

java对字符串有一个优化措施：字符串常量池(堆中)

java推荐我们使用字面量/直接量的方式来创建字符串，并且会缓存所有以字面量形 式创建的字符串对象到常量池中，当使用相同字面量再创建对象时将复用常量池中的对象以减少内存 开销，从而避免内存中堆积大量内容相同的字符串对象