java笔记

第一章java相关

大公司面试

重要:

数据结构的知识

-------------------------------

*掌握原理

-------------------------------

有价值的认证：

oracle dba认证

CCIE认证

。。。

含金量好的认证一百来说考试费很多

-------------------------------

ERP行业

ERP企业资源计划或称企业资源规划简称ERP（Enterprise Resource Planning），由美国著名管理咨询公司Gartner Group Inc.于1990年提出来的

共享软件行业

共享软件如：

魔法兔子

迅雷

。。。

-------------------------------

*不经常使用，使用的时候能够查到的知识：

了解有这么回事，用的时候再去查

-------------------------------

*难得一用的知识：

不必太专，用的时候再查

-------------------------------

*掌握业务逻辑

-------------------------------

查看共享目录：

在IE浏览器地址栏上输入

\\ip地址，如：\\192.168.0.1

-------------------------------

*************

第一章正式讲

*************

--------------------------------

1、JAVA历史，了解即可，面试不会考

2、JAVA学习过程j2se->java web->j2ee

3、JDK1.5比1.4多了范式

4、内存很重要，要弄透

5、JAVA是解释型语言

6、一个JAVA文件中可以有多个类，但只能有一个public类，此类与文件名同名。

7、path存放的是系统调用的可执行程序的目录

classpath存放的是调用类的时候，相关联的类的目录

总结中：

1、JAVA的垃圾收理机制，免除了内存管理的麻烦。需要开辟内存的时候可以直接开辟，不需要程序员来释放。

************

递归

************

1,递归就是在方法内调用自己

2,println打印东西的时候先转换成字符串再打印

3,内存中有代码区，方法只有在执行的时候才会占用内存

4,分析程序从main方法开始分析

5,递归中，当执行一个递归函数时，每层递归都必须等待下一层递归返回具体值后，才能继续运行，向上层返回值。（不懂的话，可以参看第二章_递归_2）

--------------------------

第二章基础知识

************

标识符

************

1,可以自己取名字的,都是标识符

2,对大小写敏感,长度无限制

3,中间不可以有空格

4,java标识符要"见名知意"

************

关键字

************

************

java常量

************

************

java变量

************

1,变量本质: 内存里的一块区域

2,不同的变量类型,在内存中分配的长度不一样

3,局部变量必须要有初值

~~~~~~~~~~~~~~~~~~~~~~~~

程序执行过程中的内存管理

~~~~~~~~~~~~~~~~~~~~~~~~

1,code segment 存放代码

2,data segment 存放静态变量，字符串常量

3,stack (栈) 存放局部变量

4,heap (堆) 存放new出来的东西；动态申请内存

~~~~~~~~

局部变量

~~~~~~~~

1,在方法体内部定义的变量

2,函数的参数

~~~~~~~~

成员变量

~~~~~~~~

在方法体外，类内

~~~~~~~~~~~~

变量的作用域

~~~~~~~~~~~~

凡在{}内定义的变量，出了{}就不起作用了

************

java数据类型

************

1,逻辑型Boolean 只允许取true或false

Boolean bl;

bl = true;

2,字符型char

char eChar = 'a';

char eChar = '中';

采用Unicode编码，每个字符占两个字节，十六进制编码

转义字符'\'来将其后的字符转变为其他的含义

char c2 = '\n'; //'\n'代表换行

3,整数类型byte(1字节) short(2字节) int(4字节) long (8字节)

*long l = 8888L （L必须加，不然会被认为是int类型）

4,浮点类型float(4字节) double(8字节)

*float f = 12.3f（当所赋的值是小数的时候f必须加，不然会被认为是 double类型）浮点说在计算机中是离散的，是有一定误差的。float精确到小数点后7位，double精确到小数点后15位

************

数据类型转换

************

1,byte short char之间不会互相转换,他们在计算的时候首先转换成int类型

2,容量(所能表示的数的多少)大的数据类型转换为容量小的数据类型时,要加

上强制转换符,但可能造成数据溢出或者精度降低

*将double d = 10.1;将d转换为int类型：

int i = (int)d;

在一个数据类型转换为比他位数少的类型时，会将多的部分去掉，余下的数

是多少就是多少。

比如，int类型为4位，byte类型为1位，当int类型转换为byte类型时，会去

掉3位，余下的4个0/1表示什么，那么转换后的值就是什么。

但对float不能如此的转换为double类型，因为在内存中对于浮点数的存储不

同于整数类型的存储。这也是声明float类型时，给变量赋值为小数时时必须

加f。否则会默认为double类型，然而double类型无法转换为float类型，所

以会出错

************

程序格式

************

1,大括号对齐。即左右两个大括号所在的行的左部要一齐，而不是指括号对齐

2,程序块之间要加空行

3,运算符两侧加空格

*原则：让别人看的更清楚

************

运算符

************

1,++放在后面，先取值后计算

int i = (i2++); //先把i2的值赋值给i，然后i2再++

++放在前面，先计算后取值

--同理

2,逻辑运算符中& | 比如a&b a|b 需要计算a b真值然后给出表达式a&b a|b的真值而&& || 比如a&&b a||b叫做短路与，短路或。如对于a&&b 若a = false 则不计算b给出表达式的真值。a||b也一样，如果a确定为true则，无需计算b直接给出表达式为true

3,"+"可以做字符串连接如：String s = "hello" + "world";

4,"+"运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将一个操

作数转换为字符串然后再进行连接。

int c = 12;

System.out.println("c = " + c); //由于"c = "为字符串，所以系统会先将后面的

c先转换成字符串再连接，12转换成字符串还是12

*当使用println()进行打印的时候，无论任何类型，都在自动转化为字符串,再打印。（已经是第二次说明此问题）

println(c);时，会先将c转化成字符串再打印

************

语句

************

1,for循环中for(语句1；语句2；语句3){语句4}

执行顺序：

语句1 -〉语句2（若语句2为真）-〉语句4 -〉语句3 -〉

语句2（若语句2为真）-〉语句4 -〉语句3 -〉

语句2（若语句2为假）-〉结束for语句

2,如何分析程序：

分析内存：

每遇到一个变量就在内存中画出来

当变量的值有改动的时候，在内存中显示出来

3,do{}while(); 记住后面要有个";"

4,continue终止本次循环，continue下的语句不运行，而是直接进行下一次循环

语法与break一样如：if(i==5) continue;

************

方法

************

1,方法的作用：

增强代码的复用性

2,形参: 数据类型

实参: 数据

面向对象的思想

**************

面向对象的思想

**************

1,将与问题有关的对象和他们之间的联系抽象出来

而不是考虑第一步要做什么，第二步要做什么。

2,用面向对象的思想来思考问题的步骤

第一步：

考虑这个问题域里有哪些类，哪些对象

第二步：

这些类，这些对象有哪些属性

第三步：

考虑他们之间的关系，他们应该有哪些方法

3,合适的方法应该出现在合适的类里

4,跟业务逻辑无关的方法不需要出现在类中

5,Java中“外事万物皆对象”

******************

面向对象的基本概念

******************

1,对象的属性，即成员变量，在声明的时候可以初始化，如果不初始化java默认初始化Boolean类型为false 引用类型为null 其他为0 或0.0

2,引用类型（8种基本类型之外的类型）占两块内存

3,java中的对象是通过引用对其操作的

比如：Dog d = new Dog("Tom");

Dog d时，d要在内存中开辟一个空间，初始为null

当new后，会在堆中动态的开辟一个内存来存放Tom，此时d的值为Tom

但不能直接访问Tom，需要通过d来访问，类似C++语言中的指针

4,引用：

一小块内存指向一大块内存

使用方法：对象.成员变量

对象.方法

这里的"."相当于C++里的->

5,同一个类的不同对象在内存中有不同的空间，但共用方法和属性

6,构造方法：

名字与类名一样，无返回值。与new一起使用创建一个新对象

public class Person {

int id;

int age = 20;

//类Person的构造方法

Person(int _id,int _age) {

id = _id;

age = _age;

}

}

Person p = new Person(1,40); //此处的Person(1,40)是类Person的构造方法

当不写构造方法的时候，系统默认创建一个形如：类名(){} 这样的构造方法。

但当自己写了构造方法后，当创建类的时候，就必须使用自己创建的构造方法了。

7,约定俗成的命名规则：

类名，首字母大写

方法名、变量名，小写

运用驼峰标示

第三章java学习之类的学习

************

方法

************

1,重载:

方法名一样参数不一样

在调用的时候会根据参数的不同调用不同的方法

2,构造方法也可以重载

3,确定方法的步骤

第一步: 确定方法的名字

第二步: 确定方法的参数

第三步: 确定方法的返回值

************

this关键字

************

1,this可以看作是一个变量，值是当前对象的引用

2,用来处理方法中，成员变量和参数重名的情

************

static关键字

************

1,static 声明的成员变量为静态成员变量，它为该类的公用变量2,不需要new对象即可使用

如：类名.静态成员变量= 100; 即可

对象也可以使用

如：对象.静态成员变量= 200;

3,可以用来计数

4,在static方法中不能访问非static成员变量

**************

package,import

**************

1,包名：

公司域名倒过来写

2,package语句必须位于java代码的第一行

3,package中用.来说明目录的层次

如：package com.sxt

则该文件中所有的类位于.\com\sxt目录下"." 为当前目录4,使用import引用一个包里的类

如：import com.sxt.MyClass; //引入com.sxt里的MyClass类import java.util.*; //引入java.util包里所有的类

5,访问位于同一个包中的类不需要import引用包，可以直接使用6,执行一个类,必须包括其所在的包名

(使用命令提示符执行class文件时)

7,https://www.360docs.net/doc/9c11290339.html,ng使用时可以不引用，其他的包使用时需要引用

8,如何打jar包：

cd 到要打包的类的目录

jar -cvf xx.jar(jar包的名字) xx.xx(要打包的类的名字和后缀

*.*代表所有的类)

可以把其所在的路径放到classpath里便于调用里面的类

**************

继承和权限控制

**************

1,使用extends关键字实现类的继承

通过继承，自类自动拥有了基类(父类)的所有属性和方法

私有的属性也会被继承，但是无法访问，即无法修改和使用其属性

写法：

public(可选项) class 子类名extends 基类名{}

2,java不允许多重继承

3,权限控制范围

private 类内

default 类内包内（就是class前什么都不写）

protected 类内包内子类

public 任何地方

只有default和public可以修饰class

4,方法重写

在子类中可以根据需要对从基类中继承的来的方法进行重写

重写方法必须和被重写方法具有相同的方法名，参数列表，返回类型

重写方法不能使用比被重写方法更严格的访问权限

5,super用来引用基类的成分，相当于在一个父类的对象，且不需要声明可以直接引用

如：

子类在重写父类的方法f()时，可以

public void f() {

super.f(); //将父类f()这个方法引用进来

value = 200; //再写自己的方法

//要注意的是，如果父类里有value，子类的value

//和它占用不同的内存，简单来说，他们不是一个//value

}

6,子类的构造方法中必须调用其父类的构造方法，即在子类构造方法中，应使用super(子类构造函数的形参)，且必须写在构造方法的第一行

如：

public class Worker extends Person implements CarePet {

//子类构造函数

Worker(String name) {

super(name);

}

}

如果子类的构造方法没有显示的调用父类的构造方法，则默认调用无参的

构造方法

this(参数列表) 调用自己的其他构造方法

7,Object类

是所有Java类的基类，可以重写其中的方法。

比如：Object类里的toString()方法，与字符串作连接或者直接打印出来的时候，转换成字符串。这个方法经常被重写。

正常情况下，无需写出，会默认执行

equals()方法也经常需要重写，在比较类的对象a,b是否相同的时候，equals() 默认认为，传进来的对象的引用和调用它的对象的引用所指向的是同一对象才会返回true

**************

对象转型

**************

1,一个基类的引用可以指向其子类

比如：

class Person {}

class Son extends Person {

private myLove;

public void mine(){}; //子类自己的方法

}

public class Test {

public static void main(String[] args) {

Person p = new Person();

p = new Son(); //一个基类的引用指向其子类

//但其不可以访问子类自己的方法mine()

//也不可以访问子类自己属性myLove

//此时p还被认为是Person类的一个对象

//需要强制转换才能成为为Son类型

}

}

2,可以使用instanceof来判断一个引用是否为一个类

比如：

p instanceof Person

这个式子返回一个true 或者false 这里显然是true

3,可以通过强制转换，将基类转换成子类

比如：

Son s1 = (Son)p; //将p强制转换成Son类型

同级的类，无法转换

比如：猫类不能转换成狗类

**********************

多态：迟绑定，动态绑定

**********************

1,增强了可扩展性

2,多态的3个必要条件

1,要有继承

2,要有重写

3,父类引用指向子类对象

3,在执行的时候,根据new出来的对象来动态得调用对应

的被重写的方法

比如:

class Animal {

protected String name;

protected void enjoy() {

System.out.println("开心");

}

}

class Cat extends Animal {

private String eyesColor;

public void enjoy()

}

****

抽象

****

1,用abstract来修饰的方法就是抽象方法,只有声明没有实现如：

public abstract void enjoy();

子类中需要对抽象方法进行重写

当一个类中有抽象方法的时候,这个类也必须被声明为抽象类如:

abstract class Animal {

......

}

抽象类必须被继承

抽象类无法new出对象，即不能实例化

***********

final关键字

***********

1,final修饰的变量，一旦被赋值就不能再改变

如：

public void m(final int j) {

j = 9; //这个是错误的，在调用这个方法的时候，j就被

//赋值，方法里面不能改变j的值

}

2,final的方法不能被重写

3,final的类不能被继承

***************

interface关键字

***************

1,接口是一种特殊的抽象类，只包含常量和方法的声明，而没有变量和方法的实现

如：

public interface Runner {

public static final int id = 1; //成员变量默认为public static final

//即，即使不标明，也是这种类型，而且

//只能是这种类型

public void start(); //默认为public

public void run();

}

public interface Painter {}

2,一个类可以实现多个接口

类继承接口的形式：

class Student implements Runner {}

class Teather implements Runner,Painter {}

3,接口可以继承其他的接口，并添加新的属性和方法

第四章异常处理

***********

异常处理

***********

1,异常exception：

程序运行期间出现的错误

try {

System.out.printlun(2/0);

} catch (ArithmeticException ae) {

System.out.println("系统出错");

ae.printStackTrace(); //打印出错的地方和原因

}

2,方法抛出异常的写法

//声名该方法可能抛出的异常

//throws 抛出自己无法处理的异常

public void someMethod() throws SomeException {

if(someCondition()) {

//构造并抛出异常对象

throw new SomeException("error");

}

}

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ //异常可以处理

try {

someMethod();

} catch(SomeException e) {

//异常处理代码

}

一个try可以有多个catch,但必须先catch小的,再catch范围大的

如:

try {

someMethod();

} catch(SomeException e) {

//异常处理代码

} catch(SomeException2 e) {

//异常处理代码

}finally {

//异常捕获后,这里的语句可以继续执行

//异常没有捕获,也会被执行

}

通常在finally语句中可以进行资源清除的工作

如：

关闭打开的文件

删除临时文件

3,Throwable为异常类的基类

其子类Error Exception

其中Error 是无法处理的异常，叫做错误

Exception 是可以处理的异常

RuntimeException 常出的异常是Exception的子类

此类错误可以不catch

* 5个关键字try catch throw throws finally

**************

使用自定义异常

**************

1,通过集成https://www.360docs.net/doc/9c11290339.html,ng.Exception类声明自己的异常类

如：

class MyException extends Exception {

private int id; //id为异常的序号

public MyException(String message,int id) {

super(message);

this.id = id;

}

public int getId() {

return id;

}

}

2,重写方法需要抛出与原方法所抛出异常类型一致异常或不抛异常如：

class A {

public void method() throws IOException {}

}

//下面这个是错的，因为抛出的异常与其父类的类型不一致class B1 extends A {

public void method() throws FileNotFoundException {}

}

//下面这3个是正确的，因为

B2抛出的异常是其父类抛出的异常的父类

B3没有抛出异常

B4抛出的异常和其父类抛出的异常一样

class B2 extends A {

public void method() throws Exception {}

}

class B3 extends A {

public void method() {}

}

class B4 extends A {

public void method() throws IOException {}

}

第五章数组

************

1维数组

************

1,声明方式

type var[]; 或type[] var;

2,Java中使用new创建数组对象

数组名= new 数组元素的类型[元素个数]

如：

int[] s;

s = new int[5];

s[0] = new Date(1,4,5);

3,静态初始化数组

int a[] = {3,9,8};

4,s.length的值为数组s的长度

length为一个属性，后面不要加()

5,类型转换

public static void main(String[] args) {

//将String类型转换为double类型

double d1 = Double.parseDouble(args[0]);

}

6,退出程序

System.exit(-1); //非正常退出

System.extt(0); //正常退出

************

2维数组

************

1,java中多维数组的声明和初始化,应按从左到右的顺序进行如:

int a[][] = new int[3][];

a[0] = new int[2];

a[1] = new int[4];

a[2] = new int[3];

int a[][] = new int[][3]; // 这个是错的

2,初始化数组

静态初始化

int a[][] = {{1,2},{3,4},{5,6}};

int a[3][2] = {{1,2},{3,4},{5,6}}; //这个是错的

动态初始化

int a[][] = new int[3][2];

int b[][] = new int[3][];

b[0] = new int[2];

b[1] = new int[4];

b[2] = new int[3];

3,arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

用于从数组src从第srcPos项开始的length个元素拷贝到数组dest从第destPos 个开始的length个位置

注意，这里仅仅是拷贝引用，实际的数值还在src数组所在的内存中，所以修改src或dest两个数组的中拷贝的任何一个值，另一个的值也随之改变

第六章常用类

本章复习重点看练习代码，笔记太概括，不全。

***********

常用类

***********

1,String类

有很多常用的方法,详见代码UsuallyClass_String包的代码

如：

valueOf()可以将其他类型转换为字符串类型，默认会调用toString()方法，如果我们从写toString方法则调用我们重写的这个

不可变字符序列,即一旦初始化了String的引用，那么它所指向的内存的大小就无法改变，若要改变引用的其值，只能另辟空间，将引用指向新的空间2,StringBuffer类

相对于String类，是可变的类。可以对字符串进行，插入，删除部分字符3,基本数据类型包装类

将基础类型包装成对象

如：

public static Interger valueOf(String s) throws NumberFormatException

返回Integer对象，其中封装的整型数为字符串s所表示

4,Math类

max(double a,double b)

min(double a,double b)

random() 0.0到1.0的随即数

round()四舍五入到long类型,小数点后一位四舍五入

5,File类java.io.File类代表系统文件名（路径和文件名）

public static final String separator 路径分隔符，是静态的

6,枚举类型https://www.360docs.net/doc/9c11290339.html,ng.Enum

使用enum关键字

只能取规定的值里面的一个

public enum MyColor {red,green,blue};

MyColor m = MyColor.red;

MyColor n = 0; //是错的，只能是red green blue 里的一个

* 要学会并经常查API文档

第七章容器

************

容器

************

Collection 《interface》Map《interface》

_______| |_____ |

| | HashMap

Set《interface》List《interface》

| ____| |___

HashSet | |

LinkedList ArrayList

Set 的数据对象：无序的，不能重复的

List的数据对象：有序的，可以重复的

所谓重复可以equals的

Map 一对一对的装: Key 和value

1,容器里面装的必须是Object，是对象，不可以是基础类型。

2,同一个容器可以放不同类型的对象

3,容器类对象在调用remove contains需要比较对象是否相等,这会涉及到对对象

类型的equals方法和hashCode方法。

对于自定义的类,需要重写equals和hashCode方法以实现自定义的对象相等规则

相同的对象有相同的hashCode。当传入的对象是key的时候，需要调用hashCode方法4,重写equals应该重写hashCode方法

面向对象的编成，重设计。

************

Iterator接口

************

1,所有实现了Collection接口的类都有一个Iterator方法，用来返回一个实现了Iterator接口的对象

Iterator对象称作迭代器，用以实现对容器内元素的遍历操作

假设c为一个类的对象

Iterator i = c.iterator();

此时i是一个指针i.next() 这个是容器里存储的对象。初始i是在容器内第一个对象之前，所以i.next()就是第一个对象

i.hasNext()是判断i指向的对象是否为空

************

增强的for循环：

int[] array = {1, 2, 3, 4, 5}

for(int i :array) {

System.out.println(i);

}

好处在于语法简便

但只能用于输出数组内容

************

************

Set接口

************

1,在是用HashSet的add()方法时，重复添加无效

如：

HashSet s = new HashSet();

s.add("a");

s.add("b");

s.add("a"); //无效，即s内只会有一个"a"

************

List接口

************

1,Object set(int index, Object element) 返回值是被修改前的对象

2,要使用Collections.sort()方法必须继承Comparable接口，实现里面的public int compareTo(Object o) 这个方法

里面有好多方法

****************

如何选择数据结构

****************

1,Array读快改慢

Linked改快读慢

Hash两者之间

************

Map接口

************

1,实现类HashMap TreeMap

2,Map类中存储的键值不能重复，此类的比较，是比较hashcode,hashcode一样就一样

Auto-boxing/unboxing

在合适的时机自动打包，解包

自动将基础类型转换成对象类型

自动将对象类型转换成基础类型

************

泛型:

************

所谓泛型：

容器类后面的<>里面放上容器中所存储的类名

1,增强程序的可读性和稳定性

第八章流

************

流

************

1, 字节流(每次8位) 字符流(每次16位) 一个汉字为16位

输入流InputStream Reader

输出流OutputStream Writer

输入，输出以程序的角度

节点流：直接接在数据源上的流

处理流：包到别的流上的流

2,良好的编成方式

先写flush();再写close();

************

节点流

************

************

缓冲流

************

带缓冲区的流

************

转换流

************

InputStreamReader

OutputStreamWriter

************

数据流

************

************

打印流

************

PrintWriter PrintStream 自己有flush();功能

************

Object流

************

把Object直接转换成字节流，输出到某个地方，叫做序列化Serializable接口序列化接口叫做标记性的接口

所谓标记性的接口未定义任何方法的接口

任何可以序列化的类都需要实现Serializable接口

transient透明的用来修饰类中的成员变量起作用是在序列化的时候不考虑它修饰的变量的值，安默认的值算

externalizable接口继承于Serializable，内含两个方法

实现了自己控制自己的序列化过程，补偿使用，也不建议是用

************

流的总结

************

本章介绍了很多流,整理如下

IputStream/OutputStream 字节流

Reader/Writer 字符流