java基础知识回顾

Java学习笔记（3-21——4-2）

1、Java是一种程序设计语言，也包括程序开发和运行环境。

2、JA V A好处：加快开发速度、一次编写到处运行（跨平台运行）、支持多线程、提供一个更简单的途径（简化开发）纯面向对象

3、Java对外无指针对内有（JVM是由C++语言实现的）

4、Jdk配置：

CLASSPATH 类路径（配置到lib目录）

PATH 路径系统路径（配置到bin目录）目录文件在PATH配置就可以让可执行文件在所有目录下运行，所以bin要配置到PA TH

备注：

1）. 代表当前目录，必须要配(配置在CLASSPATH中)

2）提示java不是内部命令不是可执行应用程序或者提示不能找到某个文件，则可能是环境变量设置有问题

3）编译没问题但仍然提示NoClassDefFoundError可能是CLASSPATH配置出问题

5、Java的三种机制

1）java的虚拟机

JA V A跨平台就是因为JVM不同，Windows与Linux系统的JDK不同，JVM不同

2）垃圾回收机制

Java中用new运算符负责申请内存，释放内存是JVM通过gc机制（垃圾回收）完成。程序员只有建议权，可提出释放内存，但决定权在虚拟机。建议提出https://www.wendangku.net/doc/682331106.html,ng.System.gc()/https://www.wendangku.net/doc/682331106.html,ng.Runtime.getRuntime.gc(),可以向JVM提出建议，提出释放内存垃圾。

3）代码安全性检查

编译成*.class通过类加载器（把.class加载到内存，并且优化存在JIT[just in time]即用的时候才加载）——字节码校验(第一次类加载时校验)（1.是否遵守JVM规范2.判断是否破坏系统完整性3.是否有堆栈溢出4.参数类型书写是否正确5.类型转换是否正确）——交给解释器，解释执行

6、标识符、关键字、运算符

1）标识符用来给类、方法或变量起名称，汉字也可以用来做标识符。

2）const和goto在java中留而不用，是保留的关键字。true、false、null是保留字，但不是关键字，但还是不能做标识符。

3）

移位:

>> （右移）<<（左移）移位运算针对二进制整数前补0，负数补1

>>>无符号右移负数右移一位先变成正数

Eg:int i=7;//00000111

System.out.ptintln(7>>2);//00000001=1 右移2位相当于除4

System.out.println(7<<2);//00011100=28 左移2位相当于乘4

System.out.println(7>>34);//1 在移位前会先对32/64取余数，34%32=2

System.out.println(7>>-30);//1 对于移位是负数先+32/64转成正数再运算

++必须用于变量5++不行因为5是常量，i++可以

a++(--):先运算再++，运算取++前的数若a=5 则运算取5；

++(--)a:都先++（--）再进行其他运算，运算时取的是++后的数若a=5 则运算时取6 7、数据类型

java中的数据类型分为基本数据类型和复杂数据类型两类。

基本数据类型包括数值型（byte、short、int、long、float、double），字符型（char）及布尔型（boolean）。

复杂数据类型包括类，接口和数组等，也称引用类型，即通过对象的创建，获得引用类型的值。

注意：1）Java认为所有的整数都是int型

2）Java认为所有的浮点数都是double

8、Java注释格式

1）//注释内容单行注释（以//开始。到行末结束是注释）

2）/*注释内容*/ 多行注释

3）/**注释内容*/ 文档化多行注释

注意：2与3区别，3叫文档化注释，可以用javadoc命令抽取出去，大多用3

9、程序的结构

顺序、分支、循环

分支语句：

· if、if…else、if..else if..else

· switch、case、default、break

循环语句

· while(布尔表达式){语句}、do{语句} while(布尔表达式)

· for(;;){if(布尔表达式)break; } //死循环，加按条件的break，可以实现次数不确定循环。

while(true){条件}

、面向对象

break、continue语句：它们的不同之处在余continue语句只是结束本次循环，然后重新开始下一次的循环；而break则立即结束本层循环。

10、数组

需要存储多个数据，借助数组（元素是固定的）或集合（元素是不固定的）

1.数据在数组中的位置叫数组下标（索引），从0开始。下标不同，对应的元素不同

2.每一个数据叫做数组元素，元素的个数叫数组长度。0=<下标<数组长度

3.数组是一个整体，由同一类型数据组成，属于引用类型。

声明数组时，并没有创建一个对象

格式1. int[] arr;(常用) int[]是变量类型，说明是一整形数组arr是变量名

2.int arr[]; 容易误解成整型

当定义数组(new)以后，数组元素有默认值：boolean型是false，数字默认值是0，不同精度的0或者0.0；引用类型默认值是：null ，char默认值是…\u0000?表示第一个字符

二维数组：由一位数组组成，数组元素是一维数组的，只能是同一类型的。

定义int[][] arr=new int[n][];定义长度只要定义有几个一维数组就可以，要在第一个[]中指明后面的[]要定义的是一维数组的长度（可以不定义）

Eg：int[][] arr=new int[5][];//一维数组无长度，无法分配内存空间，只能取默认值，引用类型默认是null,会导致空指针异常

11、核心：万事万物都是对象。对象（object）归类按事物类型——类。对象是客观存在的，类是抽象的。编写代码用类，使用时用对象。事物特征：属性。事物行为：方法。类——对象（创建对象）

编程思想

1）看到所有的学生——对象

2）分类——学生类

3）分析特征——属性（有选择）定义属性类型和变量名

4）分析行为——方法（有选择）

12、内存分类

1）栈内存（地址，基本类型值）类似于目录后进先出，先进后出(抽屉放书取书)

2）堆内存（对象，地址，基本类型值都可以放进去）

3）寄存器（中间数字数字运算）

4）（方法构造）代码段

5）池内存（常驻内存的对象）

类引用对象

Student s = new Student() JVM先找栈再通过栈再找堆，gc回收的是堆，

1）s要先放进栈，Student s表示声明，s以Student形式

2）new Student()是一个堆，里面有一个Student对象

3）通过等号栈中的s指向堆中的对象

13、变量分类：

成员变量（属性）声明直接在类体括号中；成员变量中由static修饰的叫类变量，类变量在本类的括号中任何一个位置使用；无static修饰的叫做实例变量，实例变量可以在本类中非static的地方使用。所有的成员变量（属性）都有一个默认值，和数组元素默认值一样。局部变量：声明不是直接在类体括号中，叫局部变量，其作用域声明所在的{}中可以使用Eg：

public class TestField{

int a1=2;//实例变量，有static修饰的地方不能使用

static int a=2;//类变量，可以在任何位置使用

public void test(int a3)//局部变量，只能在括号内

{

int a2=2;//局部变量，只能在括号内

for(int i=0;i<5;i++){//i的作用范围

}

}

}

14、值传递（引用的值不可变，引用的值的内容可变）

Java 编程语言只有值传递参数，也就是说，参数不能由被调用的方法来改变。当一个对象实例作为一个参数传递到方法中时，参数的值就是对象的引用。对象的内容可以在被调用的方法中改变，但对象引用是永远不会改变的。

15、面向对象的三个基本特征是封装、继承和多态

1）封装：a.隐藏信息b.使方法的实现细节不可见c.统一对所有用户的接口d.提高效率2）继承：通过已有的类去扩展新的类。

3）多态：同一类域的不同对象在调用相同方法的时候表现不同的现象(针对对象的行为而言)。

16、封装：所有非常量属性基本都需要封装

1.私有属性，用private

2.提供public方法操作属性，用读/写方法（get/set）

3.在构造中调方法

封装好处：

1.可以隐藏类的实现细节，

2.对所有用户提供统一接口

3.保证属性安全有效

4对以后的维护拓展有效

Eg:

public class student{

String name;

private int age;//类外隐藏,对类外提供读getAge/写setAge方法public student(){};//无参构造

public student(String name,int age)//全参构造

{https://www.wendangku.net/doc/682331106.html,=name;

//this.age=age;不好，

setAge(age);//写一次其他地方调用（代码复用）

setName(name);

}

public void setName(String name){

https://www.wendangku.net/doc/682331106.html,=name;

}

public String getName()

{

return name;

}

public int getAge(){

return age;

}

public void setAge(int age)

{

if(age>0&&age<130)

{

this.age=age;//this.age代表属性age，age是局部变量

}else{

System.out.println("不合理年龄");

}

}

17、继承：在面向对象程序设计中，继承是不可或缺的一部分。通过继承可以实现代码的重用，提高程序的可维护性。

作用域修饰符：修饰符主要用于设置成员变量(包括成员方法)的访问权限。

修饰符同类同包子类所有类和包

public 能能能能

protected 能能能

默认能能

private 能

1）子类可以继承父类中所有可被子类访问的成员变量和成员方法，但必须遵循以下原则：（1）子类能够继承父类中被声明为public和protected的成员变量和成员方法，但不能继承被声明为private的成员变量和成员方法；

（2）子类能够继承在同一个包中的由默认修饰符修饰的成员变量和成员方法；

（3）如果子类声明了一个与父类的成员变量同名的成员变量，则子类不能继承父类的成员变量，此时称子类的成员变量隐藏了父类的成员变量；

（4）如果子类声明了一个与父类的成员方法同名的成员方法，则子类不能继承父类的成员方法，此时称子类的成员方法覆盖了父类的成员方法。

2）构造方法的继承：假如在一个类中定义了构造方法，而由这个类派生出来的子类也定义了构造函数，则生成新的子类对象的时候，构造方法的执行情况：在执行子类的构造函数之

前，先执行父类的构造函数。这样的执行顺序可以保证子类对象从父类对象继承得到的成员能够进行正确的初始化。

18、重写：方法覆盖即子类中直接定义和父类同名的方法，但重新定义了方法体，即子类与父类方法的形参，返回值都相同，而内部处理不同。这中方法在使用过程中，Java虚拟机会根据调用这个方法的类来确定具体调用哪个方法。注意，用关键字final修饰的方法不能重写。

方法的重载：即在同一个类中定义了多个同名的方法，但有不同的形参，而且每个方法有不同的方法体。一个方法的特征仅包括“方法的名字”，“参数的数目及类型”，而不包括“方法的返回类型”，“参数的名字”及“抛出的异常”。编译器也会根据这些条件判断两个方法是否重载方法。

19、抽象类

1.抽象类中不一定有抽象方法。

2.含有抽象方法的类一定是抽象类

抽象类：1.强制性，必须要继承重写 2.规范性重写规范

20、接口

Interface接口用于解决多重继承例如黄金属于货币也属于金属，但是货币与金属无继承。接口不是类，但可以看做是一种特殊的抽象类。

与抽象类区别：1.接口是多继承，抽象类是类是单继承；

2.接口使用interface关键字，抽象类使用class关键字；

3.接口无构造，抽象类有构造；

4.接口里面所有的属性都是常量，而且由public static final修饰，抽象类属性不是。

5.接口中所有的方法都是public abstract,但是抽象类中的方法可以不是抽象方法(有抽象方法的一定是抽象类)

共同点：接口大多数情况当抽象类使用

类和类之间用extends 是单继承

类和接口用implents 多继承

接口和接口之间用extends多继承

abstract与static修饰方法不能一起，因为类名.调用不行，也不能与final一起，也不能与private 一起。

接口：接口的方法需要子类去重写

21、内部类

Java语言允许在类中定义内部类，内部类就是在其他类内部定义的子类。

1）内部类分为成员内部类、局部内部类、静态内部类、匿名内部类。

几种内部类的共性：

A、内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类命和$符号。

B、内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否是private的。

2）成员内部类（不能被public修饰）：形式如下

class Outer {

class Inner{}

}

编译上述代码会产生两个文件：Outer.class和Outer$Inner.class。

成员内部类内不允许有任何静态声明！下面代码不能通过编译。

class Inner{

static int a = 10;

}

能够访问成员内部类的唯一途径就是通过外部类的对象！只有创建了成员内部类的实例，才

能使用成员内部类的变量和方法。

Eg: Sample s = new Sample();

s.Innner inner = s.new Inner();

3）局部内部类:局部内部类和局部变量一样，都是在方法内定义的，其有效范围只在方法内部有效。局部内部类可以访问它的创建类中的所有成员变量和成员方法，包括私有方法。

Eg:

Public class outer{

public void doSomething(){

final int a =10;

class Inner{

public void seeOuter(){

System.out.println(a);

}

}

Inner in = new Inner();

in.seeOuter();

}

public static void main(String[] args) {

Outer out = new Outer();

out.doSomething();

}

}

4) 静态内部类:静态内部类和静态变量类似，它都使用static关键字修饰。

一般格式为:

public class Sample {

static class Apple { // 静态内部类

}

}

静态内部类可以在不创建Sample类的情况下直接使用。

Eg：class Outer{

static class Inner{}

}

class Test {

public static void main(String[] args){

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

}

}

5）匿名类就是没有名称的内部类，它经常被应用于Swing程序设计中的事件监听处理。A、继承式的匿名内部类。

class Car {

public void drive(){

System.out.println("Driving a car!");

}

}

class Test{

public static void main(String[] args) {

Car car = new Car(){

public void drive(){

System.out.println("Driving another car!");

}

};

car.drive();

}

}

结果输出了：Driving another car! Car引用变量不是引用Car对象，而是Car匿名子类的对象。建立匿名内部类的关键点是重写父类的一个或多个方法。再强调一下，是重写父类的方法，而不是创建新的方法。因为用父类的引用不可能调用父类本身没有的方法！创建新的方法是多余的。简言之，参考多态。

B、接口式的匿名内部类。

Public interface Vehicle {

public void drive();

}

Public class test{

public static void main(String[] args) {

Vehicle v = new Vehicle(){

public void drive(){

System.out.println("Driving a car!");

}

};

v.drive();

}

}

上面的代码很怪，好像是在实例化一个接口。事实并非如此，接口式的匿名内部类是实现了

一个接口的匿名类。而且只能实现一个接口。

C、参数式的匿名内部类。

Public class Bar{

void doStuff(Foo f){}

}

Public interface Foo{

void foo();

}

Public class Test{

static void go(){

Bar b = new Bar();

b.doStuff(new Foo(){

public void foo(){

System.out.println("foofy");

}

});

}

}

22、事件机制

1.event object：就是事件产生时具体的“事件”，用于listener的相应的方法之中，作为参数，一般存在于listerner的方法之中

2.event source：具体的接受事件的实体，比如说，你点击一个button，那么button就是event source，这样你必须使button对某些事件进行响应，你就需要注册特定的listener，比如说MouseEvent之中的MouseClicked方法，这时它就必须有了add方法

3.event listener：具体的进行监听的事件类，当有其对应的event object产生的时候，它就调用相应的方法，进行处理。在windows程序设计里边这种响应使用callback机制来实现的基本步骤：

（1）装载事件包。如：import java.awt.event.*;

（2）实现事件监听器所对应的接口。

如：class Xxx implements ActionListener

（3）对事件源（即组件）添加事件监听器。

如：btn.addActionListener(this);

（4）重写相应事件接口类中的方法。

23、范型的使用

范型的好处

1、一次性的开发、测试和部署代码，通过任何类型来重用它

2、编译器支持和类型安全

3、不会强行对值类型进行装箱和取消装箱，或者对引用类型进行向下强制类型转换，所以性能得到显著提高。

范型的用法：

;

T代表类型变量（八种基本类型的包装类和引用类型）

范型类可以有多个类型变量,eg public class Pairs{…};

(？是类型通配符);

采用通配符的原因是因为范型是协变的

范型是协变的：

List intList = new ArrayList();

List numberList = intList; // invalid

一个List不是一个List