Java基础学习笔记整理

2024年2月8日发(作者：)

Java学习笔记整理——李兴华视频归纳

Java学习笔记之一

一、环境变量设置

1、JDK下载链接地址：

/technetwork/java/javase/downloads/

下载完毕后，进行安装，比如安装到C:Program FilesJavajdk1.6.0_12目录下，安装完毕后设置环境变量，需要设置的项如下：

（1） JAVA_HOME: C:Program FilesJavajdk1.6.0_12

（2） PATH:C:Program FilesJavajdk1.6.0_12bin

（3） CLASSPATH: .;%JAVA_HOME%;%JAVA_HOME%;

//注意：点号、分号一定不能丢掉了。

2、开发工具IDE下载地址：

（1）Eclipse：/downloads/

（2）Netbeans: /

（3）Jcreator：/

3、开发工具IDE-Eclipse常用快捷键：

/blog/1290525

二、Java基本介绍

1、Java历史特点：

Java自1995年诞生，至今有16年的历史，从诞生之日起，逐渐被广泛接受并成为推动了web迅速发展。Java的三种核心机制为虚拟机机制、代码安全机制、垃圾回收机制。

Java最大的特点是平台无关性（可移植性好），通过不同的虚拟机与各类操作系统无缝结合。虚拟机实例是指：执行一个应用程序的时候，虚拟机产生一个实例对象来支撑应用程序的运行。

2、类和对象：

类是对现实世界某一类事物的抽象和提取，比如现实世界中有许多各式各样的人，同时每一个具体的个体的名字、性别、身高都是差异化的，更进一步地将这些实例对象抽象成具有某些特征的一类事物，这就是类。类中包括属性、方法等。

3、面向对象语言的三大特征：

封装、继承、多态是面向对象语言的三大特征。

封装：将类的成员变量、构造方法或者成员方法私有化private，不直接暴露给外部使用者，而是通过提供一些接口供外部调用。

继承：子类一方面通过继承父类的非私有化的成员变量、成员方法来实现自己，并能够在此基础上进一步拓展一把自己。

多态：多态涉及到的是一个类型向上转型和向下转型的问题，通过父类搞出许多子类对象，每个子类对象都有自己的特点。

三、代码实战操作

1、 编写最简单的helloworld程序并运行查看效果。

2、 程序的注释方法、类名、变量名、方法名命名规则学习等。

3、 Java语言的基本数据类型（四类八种）引用数据类型：数组、接口、类。

4、 Java语言的表达式、运算符、判断和循环语句等。

5、 数组的定义、使用，方法的声明和使用演练等操作。

四、面向对象语言基础部分

面向对象语言的三大特征是：封装、继承、多态

下面先介绍封装和继承，然后再介绍多态性。

Java学习笔记整理——李兴华视频归纳

父类：人类Person

子类：学生类Student

子类向父类转型为向上转型，父类向子类转型为向下转型也叫做强制转换。

代码如下：

/**

* @author Administrator

*

* @description 父类，基类

* @history

*/

class Person{

}

/**

* @author Administrator

*

private String name; // private进行封装操作

private int age;

// 覆写toString方法

@Override

public String toString() {

}

public Person(String name,int age){ // 全参数构造方法

= name;

}

public Person(){ // 无参数构造方法

//do nothing

}

// getter/setter方法

public String getName() {

}

public void setName(String name) {

}

public int getAge() {

}

public void setAge(int age) {

}

= age;

return age;

= name;

return name;

= age;

return "Person[name=" + name + ",age=" + age + "]";

Java学习笔记整理——李兴华视频归纳

* @description 子类，继承自父类person

* @history

*/

class Student extends Person{

}

public class MyDemoTest{

/**

*@description

*@param args

*/

public static void main(String[] args){

}

// 定义并实例化父类对象

Person p = new Person("java",16);

n(p); // 调用toString方法

// 定义并实例化子类对象

Student s = new Student("java",16,"sun");

n(s); // 调用toString方法

Person p1 = new Student("eclipse",12,"ibm"); // 实例化子类对象赋给父类对象

Student s1 = (Student)p1; // 父类向子类转换，强制类型转换-向下转型

n(s1);

private String school; // 子类拓展的属性，学校

// 覆写toString方法

@Override

public String toString() {

}

public Student(String name,int age,String school){

}

public Student(String name){

}

// getter/setter方法

public String getSchool() {

}

public void setSchool(String school) {

}

= school;

return school;

super(); // 调用父类无参数构造方法

= name;

super(name,age); // 调用父类带两个参数的构造方法

= school;

return "Student[name =" + e() + ",age = " + ()

+ ",school=" + school + "]";

Java学习笔记整理——李兴华视频归纳

}

/**

* @author Administrator

*

* @description

* @history

*/

public class MyFirstDemo {

// 类名、方法名、变量名等命名规则

// 一律做到简单明了，容易明白——简单就是美

// 1、类名首字母采用大写形式，如果是多个单词拼接采用驼峰形式

// 2、方法变量名首字母采用小写形式，方法名一般是动+名，变量命名做到见名知意

/**

*@description main方法程序的入口

*@param args 参数

*/

public static void main(String[] args) {

n("hello world"); // 最简单的hello world程序

// 基本数据类型——四类八种 // 引用数据类型——接口、数组、类

// byte,short,int,long,float,double,boolean,char

byte b = _VALUE; // 基本数据类型的包装类

short s = _VALUE; // short类型的最大值

int i = _VALUE; // int类型的最小值

long l = _VALUE; // long类型的最大值

float f = 1.50f; // 定义float类型变量需要设置f

double d = 1.50d; //定义double类型变量需要设置d

char c = 'c'; // 定义char类型字符

boolean boo = ; // 定义boolean类型值

// 遵循变量先声明后使用原则

// 类型转换，精度高的向精度低的转换为强制类型转换

byte b1 = 25;

int i1 = b1; // 自动转换，提高精度

int i2 = 350;

byte b2 = (byte)i2; // 强制类型转换，精度丢失

int sum = 0; // 定义变量时候养成初始化变量的习惯

byte s1 = 1;

int s2 = 125;

sum = s1 + s2; // byte类型会自动转换成int类型，类型提升

// 设计模式-襄垣模式

Java学习笔记整理——李兴华视频归纳

}

Integer in1 = 125;

Integer in2 = 125; // in1==in2 true

// 注释方式 // /* 注释部分，代码不生效*/ /** 文档注释**/

// 表达式、运算符、判断循环分支语句和C语言类似

// if for while do while break continue switch case以及+ - * % /等等

// 数组的定义、使用以及方法的定义和使用

int[] array = new int[10]; // 定义整型数组并且数组长度为10

for (int j = 0; j < ; j++) {

array[j] = j + 1; // 初始化数组元素

}

int tmp = 0;

while (tmp < ) {

n(array[tmp++]); // 使用输出数组元素

}

sayHelloWorld(); // 调用静态方法sayHelloWorld()

}

// 定义方法private该类内部才能够调用的方法

// static静态方法、方法名称动+名，首字母采用小写

private static void sayHelloWorld() {

}

n("hello world");

Java学习笔记之二

一、面向对象基础部分

1、this、super关键字

基类：BaseTest

public class BaseTest {

}

/**

* @author Administrator

*

* @description this,super关键字测试类

* @history

protected String pwd; // 定义protected属性pwd

public BaseTest(){

}

public String sayHelloWorld(){

}

return "hello world";

// 无参数构造方法

Java学习笔记整理——李兴华视频归纳

*/

public class MyTestDemo extends BaseTest{

// notes:测试使用而已，代码功能模拟而已

private String username; // 定义用户昵称私有属性private修饰

private String password;

public MyTestDemo(String username){ // 构造方法

}

public MyTestDemo(){

// 无参数构造方法

super(); // 调用父类无参数构造方法

}

public void sayHello(){

d(); // this.方法调用当前对象的sayWord方法

loWorld(); // super.方法调用父类sayHelloWorld方法

}

public String sayWord(){

}

// this表示当前对象

public boolean equals(Object obj){

}

/**

*@description

*@param args

*/

public static void main(String[] args) {

// this关键字绑定了当前该对象，通过this.属性、this.方法

// super关键字用在子类要调用父类的属性或者方法中，通过super.属性、super.方法

MyTestDemo obj1 = new MyTestDemo("hello-java"); // 定义并实例化对象

MyTestDemo other = (MyTestDemo)obj; // 传入的比较对象，强制转换操作

// 简单模拟，如果对象的username属性值相同那么就认为相同

if(this == other){

}

if(other instanceof MyTestDemo){

}

return false;

if((me)){

}

return true;

return true;

return "hello this";

this();// this()调用无参数构造方法

me = username; // this.属性访问当前username属性

// super.属性调用父类属性

rd = ;

Java学习笔记整理——李兴华视频归纳

}

}

lo(); // 调用对象的sayHello方法

MyTestDemo obj2 = new MyTestDemo("hello-java");

// equals方法传入的参数类型为object，传入的obj2会自动向上转型处理

boolean result = (obj2);

n(result); // true

2、static、final关键字

/**

* @author Administrator

*

* @description final和static关键字学习

* @history

*/

public class FinalAndStaticTestDemo {

/**

*@description

*@param args

*/

public static void main(String[] args) {

// final关键字主要有三种场景

// 1、final定义的变量为常量，比如基本数据类型的值一旦初始化了不能改变

// 2、final定义的类为终结类，不能再被继承，比如string类型

// 3、final定义的方法为终结方法，不能被覆写，否则编译器会报错

final String str = "helloworld"; // final修饰变为常量不能改变

//str = "hellojava"; // eclipse提示:The final local variable str cannot be

assigned.

// 进一步思考下面两个问题

String s1 = "hello";

String s2 = "hello1";

final String s = s1;

s1 = s2;

n(s); // hello还是hello1呢

// 引用不可变，内容可变是这个意思吗?

StringBuffer sb = new StringBuffer();

("hello");

final String fs = ng();

final StringBuffer fsb = sb;

("world");

n(fs);// hello还是helloworld呢

Java学习笔记整理——李兴华视频归纳

}

}

n(ng()); // hello还是helloworld呢

// static关键字比较类似也有下面三种场景

// static修饰的变量为静态变量，它不同于对象/实例变量，是关联在某个类上的

// static修饰的类为静态类

// static修饰的方法为静态方法，它也不同于对象/实例方法，是关联在某个类上的

// static int i = 100;

// static class HelloWorld{ //... }

// public static void sayHeloWorld(){ //... }

// 静态变量和对象变量

static int i = 100; // 定义静态变量i

int j = 100; // 定义成员变量/实例变量

public static void sayHelloWorld(){ // 定义静态方法sayhelloworld

n("hello world");

}

static class HelloWorld{ // 定义内部类

// ...

}

3、引用传递介绍和应用

/**

* @author Administrator

*

* @description 引用传递的简单学习

* @history

*/

class DemoTest{

String ide = "eclipse"; // 为了方便访问暂不封装

}

public class MyDemoTest{

/**

*@description

*@param args

*/

public static void main(String[] args){

// 对象属性值访问和变更

DemoTest dt1 = new DemoTest();

n(); // eclipse

= "netbeans"; // 改变ide属性值

n(); // netbeans

Java学习笔记整理——李兴华视频归纳

}

function(dt1); // 调用方法function

n(); // jcreator

// String类赋值和变更

String ide = "eclipse";

function(ide);

n(ide); // eclipse而不是netbeans

}

private static void function(String ide) {

ide = "netbeans"; // 赋值为netbeans

}

// 测试方法function

private static void function(DemoTest dt2) {

= "jcreator"; // 改变ide属性值

}

4、静态块、代码块、同步块

/**

* @author Administrator

*

* @description 静态块、代码块、同步块学习测试类

* @history

*/

class BlockDemo {

public BlockDemo() {

}

// 构造方法、构造代码块和静态代码块初始化顺序呢?

n("BlockDemo->BlockDemo");

static {

}

{

}

// 在类中定义的{ //...}为构造代码块

// 构造代码块和对象一起初始化的

n("BlockDemo->{}");

// 在类中定义的static{ //...}为静态代码块

// 静态代码块的程序只会被初始化一次

n("BlockDemo->static");

// 静态块、构造块、构造方法 // 表面初步分析，具体有待研究

}

public class MyDemo {

/**

Java学习笔记整理——李兴华视频归纳

}

* @description

* @param args

*/

public static void main(String[] args) {

}

// 静态块、代码块、同步块

{

// 在方法中用{ //... }定义的为普通代码块

int x = 100;

n(x); // 100 相当于局部变量

}

int x = 200;

n(x); // 200

new BlockDemo();

new BlockDemo();

// BlockDemo->static static代码块只会被初始化一次

// BlockDemo->{}

// BlockDemo->BlockDemo

// BlockDemo->{}

// BlockDemo->BlockDemo

5、构造方法、匿名对象、单例定义以及实现

/**

* @author Administrator

*

* @description 构造方法、匿名对象、单例学习测试类

* @history

*/

public class MyDemoTest {

private String username; // 定义私有属性username

// 构造方法的作用是初始化操作

// 构造方法是一种特殊的方法，构造方法也有重载

public MyDemoTest(){

// 无参数构造方法

}

public MyDemoTest(String username) { // 定义构造方法

me = username; // 对属性初始化赋值操作

}

/**

*@description

*@param args

Java学习笔记整理——李兴华视频归纳

}

*/

public static void main(String[] args) {

}

// 实例化一个匿名对象

// 匿名对象不在栈中开辟空间赋地址值

new MyDemoTest("eclipse");

/**

* @author Administrator

*

* @description 单例学习测试类

* @history

*/

class Singleton {

}

class Singleton2{

private Singleton2(){

}

// 懒汉式获取单例代码

private static Singleton2 instance = null;

private static Object lock = new Object();

// 获取单例方法，效率比较低

// 每次进入都要进行锁判断，而实际情况我们是第一次null比较特殊

/*public static Singleton2 getIntance(){

synchronized (lock) {

}

return instance;

if (instance == null) { // 如果为null进行实例化对象操作

instance = new Singleton2();

}

// 构造方法私有化，外部不能直接调用

n("private Singleton2(){//...}");

private Singleton() {

}

// 饿汉式获取单例代码

private static Singleton instance = new Singleton();

// 对外提供一个getInstance方法获取单例

public static Singleton getIntance() {

}

return instance;

// 将构造方法私有化，外部不能直接调用

n("private Singleton(){//...}");

Java学习笔记整理——李兴华视频归纳

}

}*/

// 上面同步代码的另外一种写法如下，效率比较低

// public static synchronized getInstance(){ //...}

// 对同步代码进行改写

public static Singleton2 getIntance(){

}

if(instance == null){

}

return instance;

synchronized(lock){

}

// 如果换为下面这种形式那么就可能不是产生一个实例对象了

/*synchronized(lock){

instance = new Singleton2();

}*/

if(instance == null){ // 进行双重检验操作

instance = new Singleton2();

}

6、内部类、匿名内部类应用

class Outer{ // 定义外部类

}

/**

* @author Administrator

*

* @description 内部类以及匿名内部类学习测试类

* @history

private String info = "helloworld" ; // 定义外部类属性

private static String info2 = "helloeclipse"; // 定义静态变量

class Inner{ // 定义内部类

public void print(){

}

static class StaticInner{ // 通过static定义的内部类为外部类

public void print(){

}

public void fun(){

new Inner().print() ; // 通过内部类的实例化对象调用方法

}

}

n(info2);

// 内部类的好处之一：直接访问外部类属性

n(info) ; // 直接访问外部类属性

}

Java学习笔记整理——李兴华视频归纳

*/

public class InnerClassDemo{

}

/**

*@description

*@param args

*/

public static void main(String[] args){

}

new Outer().fun() ; // 调用外部类的fun()方法

// 另外一种实例化方式

Outer out = new Outer();

in = Inner();

();

// 通过外部类.内部类实例化内部类对象

//StaticInner sin = new Inner(); //需要导入外部类所在的包

//();

二、面向对象高级部分

1、继承的进一步讨论

class Base{

}

class ZiLei extends Base{

// 定义子类覆写print方法

void print(){

}

/*void print1(){

// Cannot reduce the visibility of the inherited method from Base

}*/

// 覆写override和重载overload区别

// 子类访问父类中的方法，前面super关键字内容

// ();

n("Super->print()");

// 定义基类

void print(){

}

public void print1(){

// 父类方法的访问权限，子类覆写该方法的时候不能降低权限

}

n("Base->print()");

// 覆写是父类子类之间的关系，重载是同一个类之间的关系

}

/**

Java学习笔记整理——李兴华视频归纳

* @author Administrator

*

* @description 继承中的方法覆写

* @history

*/

public class OverrideDemo{

}

public static void main(String args[]){

}

new ZiLei().print(); // 调用的内容是覆写后的方法实现

// 另外java中只能够单继承，不同于C++，但是可以多重继承

/*class A{

}

class B extends A{ //class C extends A,B{ // ...}编译错误

// ...

}

class C extends B{

// ...

}*/

// ...

2、接口和抽象类进一步讨论

/**

* @author Administrator

*

* @description 接口测试类

* @history

*/

interface Interface{

}

class I implements Interface{

}

public class InterfaceTestDemo {

/**

public void print() {

}

public void printInfo() {

}

// ...

// 方法实现

n(INFO); // helloeclipse

public static final String INFO = "helloeclipse";

public void print(); // 定义方法

public abstract void printInfo();

Java学习笔记整理——李兴华视频归纳

}

*@description

*@param args

*/

public static void main(String[] args) {

// 接口interface

// 接口interface和抽象类abstract一样不能直接实例化必须通过子类来实现

new Interface(){

};

// 接口和抽象类对比，接口更像一种规范、抽象类更像一种模板

public void print() {

}

public void printInfo() {

}

// ...

// 匿名内部类，方法实现

n(INFO); // helloeclipse

// 抽象类定义一些公共的实现，以及一些未实现的方法交给子类具体实现特定的功能-模板方法

}

/**

* @author Administrator

*

* @description 抽象类学习测试类

* @history

*/

abstract class Abstract{ // 定义抽象类

public final static String INFO = "helloeclipse"; // 定义全局变量/常量

abstract public void print(); // 定义抽象方法

// 抽象类不能直接实例化，抽象类的子类如果不是抽象类那么一定要实现所有的抽象方法

}

class AbstractZiLei extends Abstract{ // 定义抽象子类

}

public class AbstractTestDemo {

/**

*@description

*@param args

*/

public static void main(String[] args) {

// 接口和抽象类interface,abstract

// 抽象类：含有抽象方法的类叫做抽象类用abstract修饰的

new Abstract(){

public void print() { // 实现子类方法

n(INFO);

}

Java学习笔记整理——李兴华视频归纳

}

};

public void print() {

n(INFO); // 匿名抽象类实现

}

// 抽象类能不能被final修饰呢?final定义的类为终结类，抽象类是需要子类来实现的

// final abstract class Abstract{ //... } // 编译报错

}

3、object类和包装类进一步讨论

/**

* @author Administrator

*

* @description Object类学习测试类

* @history

*/

public class ObjectTestDemo {

/**

*@description

*@param args

* @throws ClassNotFoundException

*/

public static void main(String[] args) throws ClassNotFoundException {

// Object类学习测试代码

// 1、toString方法

// 2、equals和hashCode方法

// 3、getClass方法

ObjectTestDemo otd = new ObjectTestDemo();

n(otd);

n(ng());// 现实调用toString方法

/*

* Object类中toString方法

* public String toString() {

return getClass().getName() + "@" + tring(hashCode());

}

* Object类中equal方法

* public boolean equals(Object obj) {

return (this == obj);

}*/

// 定义昵称和年龄属性，如果昵称和年龄相同则equal方法返回true

ObjectTestDemo otd1 = new ObjectTestDemo();

me = "eclipse";

= 20;

ObjectTestDemo otd2 = new ObjectTestDemo();

Java学习笔记整理——李兴华视频归纳

}

}

me = "eclipse";

= 20;

n(otd1==otd2); // false

n((otd2)); // 如果不覆写的话返回的一直是false

// hashCode方法和equals方法的关系，没有绝对的关系

// 具体参看源代码的注释说明，在实际用中尽量同时覆写这两个方法，保持一致性

// public final native Class<?> getClass();

// getClass方法是一个本地方法，调用底层代码，返回当前对象对应的一个类对象实例

// 类对象实例，理解为内存中对应的那份字节码对象，java反射内容初步学习

// 通过字节码对象构造出一个个的对象实例

Class claz = ss();

Class claz1 = ;

Class claz2 = e("ObjectTestDemo"); // 类的完整路径

n(ss()); // class ObjectTestDemo

// VM内存中只会产生一份字节码对象

n(claz == claz1); // true

// 方法模拟，添加两个属性昵称和年龄

private String nickname;

private int age;

// 注意参数类型不要写成了ObjectTestDemo

public boolean equals(Object obj) {

}

public String toString(){

return "helloworld"; //覆写toString方法，返回helloworld

}

ObjectTestDemo otd = (ObjectTestDemo) obj; // 向上转型，强制转换

if (this == otd) {

}

if (otd instanceof ObjectTestDemo) {

}

return false;

if ((me) && == ) {

}

return true;

return true;

Java学习笔记之三

Java学习笔记整理——李兴华视频归纳

一、Java异常处理机制

/**

* @author Administrator

*

* @description 异常学习测试类

* @history

*/

public class ExceptionDemo {

/**

*@description

*@param args

*/

public static void main(String[] args) {

// Throable类是所有错误和异常的根基类

// Throable类下两个重要的子类Exception和Error

// 1、编写一个常见的异常例子

try {

}

// 2、catch多个种类的异常例子

String s1 = "1";

String s2 = "0"; // String s2 = "eclipse";

try{

int i1 = nt(s1); // 字符串解析成数字

int i2 = nt(s2);

int temp = i1/i2;

int i = 1;

int j = 0;

int r = i / j;

tackTrace();

// Exception in thread "main" eticException: / by zero

} catch (ArithmeticException ae) {

} catch(ArithmeticException ae){

tackTrace(); // 分母为0异常捕获

} catch(NumberFormatException nfe){

tackTrace(); // 数字格式转换异常捕获

}

// 3、异常可以往上抛出去例子

int[] array = new int[5];

try{

int i3 = array[5]; // 数组越界异常

} catch(ArrayIndexOutOfBoundsException aiobe){

Java学习笔记整理——李兴华视频归纳

}

}

}

// 捕获异常后往外抛出

// 在某一层统一处理掉这些异常，比如可以采用拦截器

throw aiobe;

// 4、自定义异常类，继承自Exception类

try{

// 实例化内部类对象比较特殊点

ExceptionDemo out = new ExceptionDemo(); // 先实例化外部类对象

throw MyException("hello-exception"); // 再实例化内部类对象

} catch(MyException me){

}

// hello-exception

n(alizedMessage());

// 自定义异常类

class MyException extends Exception{

}

public MyException(String msg){

}

super(msg);

二、Java多线程编程

/**

* @author Administrator

*

* @description Java多线程编程入门测试类

* @history

*/

// 方法一、继承线程类Thread

class MyThread extends Thread{

}

// 方法二、实现Runnable接口

class MyThread2 implements Runnable{

public void run() {

public MyThread(String threadName){ // 设置当前线程的名称

currentThread().setName(threadName);

}

public void run(){

}

n(tThread().getName());

Java学习笔记整理——李兴华视频归纳

}

}

n(tThread().getName());

public class SynTestDemo {

/**

*@description

*@param args

*/

public static void main(String[] args) {

// 1、线程的定义、线程和进程的区别、为什么要引入线程等

// 2、Java实现多线程的方法主要有两种：继承Thread类和实现Runnable接口

// 3、多个线程并发同时访问公共的临界资源的时候需要进行同步处理，过多的同步不当会造成死锁

MyThread t1 = new MyThread("hello-thread");

(); // 启动线程1

MyThread2 t2 = new MyThread2();

问题

}

/**

new Thread(t2).start(); // 启动线程2

}

* @author Administrator

*

* @description 多线程编程演练例子

* @history

*/

public class SynABCTest {

/**

* @description

* @param args

*/

public static void main(String[] args) {

}

// 通过具体的例子来加深对多线程的认识

// 问题为：循环打印10遍ABC

PrintThread p1 = new PrintThread(0, "A"); // 参数为线程标志和打印的内容

PrintThread p2 = new PrintThread(1, "B");

PrintThread p3 = new PrintThread(2, "C");

// 启动线程A B C

new Thread(p1).start();

new Thread(p2).start();

new Thread(p3).start();

Java学习笔记整理——李兴华视频归纳

}

// 采用实现接口的方式定义线程类

class PrintThread implements Runnable {

}

/**

* @author Administrator

*

* @description 死锁模拟测试类

* @history

*/

public class DeadLockTest {

/**

*@description

*@param args

public void run() {

}

while ( < 10) { // 打印的次数

synchronized (lock) {

}

while (!( == index % 3)) { // 从0开始执行

try {

}

(); // 打印出内容

++; // 当前线程打印次数++

index++; // 线程切换下一个

(); // 阻塞掉

} catch (InterruptedException e) {

}

tackTrace();

// 标记执行当前应该执行的线程0、1、2依次表示A B C

// 定义成静态变量，因为线程各自使用独立的栈

private static int index = 0;

private static Object lock = new Object();

private int key = 0; // 线程标志

private int print = 0; // 打印的次数

private String name; // 打印的内容

public PrintThread(int key, String name) {

}

= key;

= name;

All(); // 唤醒其他等待的线程

}

Java学习笔记整理——李兴华视频归纳

*/

public static void main(String[] args) {

// 过多的同步操作可能会造成死锁问题，死锁产生的原因是形成了环路等待

// 通过两个线程对象进行模拟，线程A完成一个操作需要资源1和资源2，线程B也是一样

// 在资源分配的过程中，线程A占用了资源1，等待资源2，此时此刻线程B占用了资源2，等待资源1

DeadThread dt1 = new DeadThread("1", true);

DeadThread dt2 = new DeadThread("2", false);

new Thread(dt1).start(); // 启动线程1

new Thread(dt2).start(); // 启动线程2

}

// 定义静态内部类、类似外部类了

static class DeadThread implements Runnable{

/**

* 定义资源1和资源2 lock1和lock2

*/

private static Object lock1 = new Object();

private static Object lock2 = new Object();

private String name; // 线程名称

private boolean run; // 执行顺序标记

public DeadThread(String name,boolean run){

}

@Override

public void run() {

if(){

// 线程1先占用资源1

synchronized(lock1){

}

// 线程2先占用资源2

synchronized(lock2){

try {

n("thread2 used lock2");

try {

n("thread1 used lock1");

(3000); // 暂时休眠3秒

} catch (InterruptedException e) {

}

// 线程1再去申请资源2，此时资源2已经被线程2占用着不放了

synchronized(lock2){

}

n("hello dead-lock");

tackTrace();

= name;

= run;

}else{

Java学习笔记整理——李兴华视频归纳

}

}

}

}

}

(3000); // 线程2暂时休眠3秒

} catch (InterruptedException e) {

}

// 线程2再去申请资源1，此时资源1已经被线程1占用着不放了

synchronized(lock1){

}

n("hello dead-lock");

tackTrace();

class MyThread1 implements Runnable {

}

/**

* @author Administrator

*

* @description 通过修改标记位停止线程

* @history

*/

public class ThreadStopDemo {

public static void main(String[] args) {

MyThread1 my = new MyThread1();

Thread t = new Thread(my, "线程"); // 建立线程对象

(); // 启动线程

try {

(50); // 适当地延迟下

} catch (Exception e) {

}

tackTrace();

private boolean flag = true; // 定义标志位

public void run() {

}

public void stop() {

= false; // 修改标志位

}

int i = 0;

while () {

}

n(tThread().getName() + "运行，i = "

+ (i++));

Java学习笔记整理——李兴华视频归纳

}

(); // 修改标志位，停止运行

}

三、Java常用类库

/**

* @author Administrator

*

* @description Java常用类-StringBuffer学习

* @history

*/

public class StringBufferTest {

/**

*@description

*@param args

*/

public static void main(String[] args) {

// StringBuffer类在处理字符串时候比较常用

// 1、StringBuffer类的append方法

// 具体的方法参数个数和类型，请参看JDK的API即可

StringBuffer sb = new StringBuffer();

("helloworld"); // string类型

("n"); // 特殊符号，换行符

(false); // boolean类型

('j'); // char类型

(1.50d); // double类型

// ... 等等

(0, "eclipse"); // 在index出插入值

e(); // 反转操作

e(1, 3, "helloeclipse"); // 替换操作

ing(1, 5); // 字符串截取操作

(0, 1); // 删除操作

f("hello"); // index出现的位置

// 2、StringBuffer类的引用传递

StringBuffer sb1 = new StringBuffer();

("hello");

fun(sb1);

n(ng()); // helloworld

// 3、StringBuffer类和String类的区别

// 一个可变、一个不可变，具体选择根据具体的场景

}

private static void fun(StringBuffer sb1) {

Java学习笔记整理——李兴华视频归纳

}

("world"); // 改变对应的值

}

import ption;

/**

* @author Administrator

*

* @description Runtime类学习测试

* @history

*/

public class RuntimeTest {

/**

* @description

* @param args

*/

public static void main(String[] args) {

// Runtime类是一个封装了JVM进程的类，每一个java应用程序都有一个JVM实例来支持

// 因此每个JVM进程对应一个Runtime类的实例对象，由java虚拟机来实例化对象

// 查看源代码发现，其构造方法被私有化了，类似单例模式

/*

* public class Runtime {

private static Runtime currentRuntime = new Runtime();

public static Runtime getRuntime() {

return currentRuntime;

}

private Runtime() {} }

// 2、Runtime类一般和Process类一起使用，可以打开本机的一些进程

Process p = null; // 定义进程变量

try {

p = (""); // 打开记事本程序

*/

Runtime run = time(); // 通过静态方法获取实例对象

// 1、查看一些JVM内存级别的参数

n(ory()); // 最大内存空间

n(mory()); // 空间的内存空间

String str = "";

for (int i = 0; i < 10000; i++) {

}

n(mory()); // 空间的内存空间

(); // 进行垃圾回收处理

n(mory());

str += i;

Java学习笔记整理——李兴华视频归纳

}

/*public Process exec(String command) throws IOException {

return exec(command, null, null);

}*/

// 底层有个ProcessBuilder类处理执行这些命令

} catch (IOException e) {

}

try {

(5000); // 让记事本程序执行5秒后关闭掉

} catch (Exception e) {

}

tackTrace();

y(); // 结束此进程

}

import tream;

class Demo{

}

import tream;

class Demo{

}

public class SystemTest {

/**

*@description

*@param args

*/

public static void main(String[] args) {

// System类和上面说到的Runtime类一样也是比较靠近虚拟机实例的类

// 1、我们经常使用的方式是打印输出操作n("hello world");

// PrintStream extends FilterOutputStream extends OutputStream

PrintStream out = ; // 获取打印流

n("helloworld"); // 打印输出

public Demo(){}

// 覆写该方法，测试System调用gc方法的过程

protected void finalize() throws Throwable {

}

n("hello-finalize");

public Demo(){}

// 覆写该方法，测试System调用gc方法的过程

protected void finalize() throws Throwable {

}

n("hello-finalize");

Java学习笔记整理——李兴华视频归纳

}

// 2、通过该类获取系统时间操作

// public static native long currentTimeMillis();

long current = tTimeMillis();

n(current); // 毫秒级别

// 3、查看系统的属性值情况

perties().list(out);

// =Java(TM) SE Runtime Environment

// =C:Program FilesJavajre6bin

// n=20.1-b02

// =Sun Microsystems Inc.

// =/

// ...等等系统值

// Properties extends Hashtable

// Key-Value的键值对形式，实现了Map接口的类

n(perty("")); // Windows 7

/*public static String getProperty(String key) {

checkKey(key);

SecurityManager sm = getSecurityManager();

if (sm != null) {

ropertyAccess(key);

}

return perty(key);

}*/

// 4、释放内存空间方法调用

// 在之前的笔记中说到了Object类，其中有个finalize方法

// protected void finalize() throws Throwable { }

Demo demo = new Demo();

demo = null; // 断开引用设置为null

(); // 强制性/显示释放内存空间，打印输出hello-finalize

// 调用的是Runtime类的释放方法

/*public static void gc() {

time().gc();

}*/

}

import xception;

import DateFormat;

import ;

/**

Java学习笔记整理——李兴华视频归纳

* @author Administrator

*

* @description 时间帮助工具类

* @history

*/

public class DateHelperUtil {

/**

*@description 对传入的date类型时间转换成字符串格式的时间

*@param date

*@return 返回字符串格式时间

*/

public static String formatDate(Date date){

}

/**

*@description 对传入的date类型时间转换成字符串格式的时间

*@param date

*@param formatStr 格式模板

*@return 返回字符串格式时间

*/

public static String formatDate(Date date,String formatStr){

}

/**

*@description 对传入的字符串格式的时间进行解析处理成date类型

*@param dateStr

*@return

* @throws ParseException 解析错误异常

*/

public static Date parseDate(String dateStr) throws ParseException{

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:");

SimpleDateFormat sdf = new SimpleDateFormat(formatStr);

return (date);

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:");

return (date);

/**

* @description 获取当前时间的字符串格式

* @return

*/

public static String getNowDate() {

}

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:");

return (new Date());

Java学习笔记整理——李兴华视频归纳

}

}

return (dateStr);

/**

*@description 对传入的字符串格式的时间进行解析处理成date类型

*@param dateStr

*@param formatStr 解析字符串的时间模板

*@return

*@throws ParseException 解析错误异常

*/

public static Date parseDate(String dateStr, String formatStr) throws

}

/**

*@description 获取当前时间的时间戳

*@return

*/

public static String getTimeStamp() {

}

SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");

return (new Date());

SimpleDateFormat sdf = new SimpleDateFormat(formatStr);

return (dateStr);

ParseException {

import eger;

/**

* @author Administrator

*

* @description BigInteger大数学习测试类

* @history

*/

public class BigIntegerDemo01 {

/**

*@description

*@param args

*/

public static void main(String args[]) {

BigInteger bi1 = new BigInteger("123456789"); // 声明BigInteger对象

BigInteger bi2 = new BigInteger("987654321"); // 声明BigInteger对象

n("加法操作：" + (bi1)); // 加法操作

n("减法操作：" + ct(bi1)); // 减法操作

Java学习笔记整理——李兴华视频归纳

}

n("乘法操作：" + ly(bi1)); // 乘法操作

n("除法操作：" + (bi1)); // 除法操作

n("最大数：" + (bi1)); // 求出最大数

n("最小数：" + (bi1)); // 求出最小数

BigInteger result[] = AndRemainder(bi1); // 求出余数的除法操作

n("商是：" + result[0] + "；余数是：" + result[1]);

}

class Student implements Comparable { // 指定类型为Student

private String name;

}

public class ComparableDemo01 {

public static void main(String[] args) {

Student stu[] = { new Student("张三", 20, 90.0f),

new Student("李四", 22, 90.0f), new Student("王五", 20, 99.0f),

public int compareTo(Student stu) { // 覆写compareTo()方法，实现排序规则的应用

if ( > ) {

}

}

return -1;

return 1;

if ( > ) {

}

return 1;

return -1;

return 0;

} else if ( < ) {

} else {

} else if ( < ) {

} else {

public String toString() {

}

return name + "tt" + + "tt" + ;

public Student(String name, int age, float score) {

}

= name;

= age;

= score;

private int age;

private float score;

Java学习笔记整理——李兴华视频归纳

}

}

new Student("赵六", 20, 70.0f), new Student("孙七", 22, 100.0f) };

(stu); // 进行排序操作

for (int i = 0; i < ; i++) { // 循环输出数组中的内容

n(stu[i]);

}

class BinaryTree {

public void printNode() { // 输出的时候采用中序遍历

if ( != null) {

}

ode(); // 输出左子树

}

( + "t");

if ( != null) {

}

ode();

public void addNode(Node newNode) {

}

// 确定是放在左子树还是右子树

if (eTo() < 0) { // 内容小，放在左子树

if ( == null) {

}

if (eTo() >= 0) { // 放在右子树

if ( == null) {

}

= newNode; // 没有右子树则将此节点设置成右子树

} else {

e(newNode); // 继续向下判断

}

= newNode; // 直接将新的节点设置成左子树

} else {

e(newNode); // 继续向下判断

}

class Node { // 声明一个节点类

private Comparable data; // 保存具体的内容

private Node left; // 保存左子树

private Node right; // 保存右子树

public Node(Comparable data) {

}

= data;

Java学习笔记整理——李兴华视频归纳

}

}

private Node root; // 根元素

public void add(Comparable data) { // 加入元素

}

public void print() {

ode(); // 通过根节点输出

}

Node newNode = new Node(data); // 定义新的节点

if (root == null) { // 没有根节点

root = newNode; // 第一个元素作为根节点

} else {

e(newNode); // 确定是放在左子树还是放在右子树

}

public class ComparableDemo02 {

}

import DateFormat;

import ;

import ;

import ask;

/**

* @author Administrator

*

* @description 任务调度程序学习类

* @history

*/

public static void main(String[] args) {

}

BinaryTree bt = new BinaryTree();

(8);

(3);

(3);

(10);

(9);

(1);

(5);

(5);

n("排序之后的结果：");

();

Java学习笔记整理——李兴华视频归纳

class MyTask extends TimerTask{ // 任务调度类都要继承TimerTask

public void run(){

}

public class TashTestDemo {

}

/**

* @description

* @param args

*/

public static void main(String args[]) {

Timer t = new Timer(); // 建立Timer类对象

MyTask mytask = new MyTask(); // 定义任务

SimpleDateFormat sdf = null ;

sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:") ;

n("当前系统时间为：" + (new Date())) ;

}

le(mytask, 1000, 2000); // 设置任务的执行，1秒后开始，每2秒重复

}

Java学习笔记之四

一、Java IO 编程

1、基本概念

Java中对文件的操作是以流的方式进行的，流是Java内存中一组有序数据序列。Java将数据从源（文件、内存、键盘、网络）读入到内存中，形成了流，然后还可以将这些流写到另外的目的地（文件、内存、控制台、网络）之所以叫做流，是因为这个数据序列在不同时刻所操作的是源的不同部分。

2、流的分类

流的分类方式一般有以下三种：

（1） 输入的方向分：输入流和输出流，输入和输出的参照对象是Java程序。

（2） 处理数据的单位分：字节流和字符流，字节流读取的最小单位是一个字节。

（3） 功能的不同分：节点流和处理流，一个是直接一个是包装的。

3、流分类的关系

流分类的根源来自四个基本的类，这四个类的关系如下：

输入流

输出流

字节流

InputStream

OutputStream

字符流

Reader

Writer

4、其他知识补充

（1）什么是IO

IO（Input/Output）是计算机输入/输出的接口，Java的核心库提供了全面的IO接口，包括：文件读写、标准设备输出等等。Java中的IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。

（2）流IO和块IO

此外，Java也对块传输提供支持，在核心库中采用的便是块IO，流IO和块

Java学习笔记整理——李兴华视频归纳

IO对比而言，流IO的好处是简单易用，缺点是效率不如块IO；相反块IO是效率比较高但是编程比较复杂。Java的IO模型设计非常优秀，它使用了Decorator模式，按照功能进行划分stream，编程过程中可以动态地装配这些stream，以便获取所需要的功能。

备注：以上资料提取自百度文库，链接地址如下：

/view/

5、代码模拟实战

类结构图示：

基础类File

import ;

import ption;

/**

* @author Administrator

*

* @description 基础File类操作

* @history

*/

public class FileDemoTest {

// 1、创建和删除文件

File file = new File("d:");

// File file = new File("d:"+tor+"");

NewFile(); // 创建文件

if (()) { // 如果文件存在，则删除文件

();

}

/**

* @description

* @param args

* @throws IOException IO异常处理

*/

public static void main(String args[]) throws IOException {

// Windows系统下的文件目录格式，这个和Unix系统等不同

// String pathSeparator = parator; // ;

// String separator = tor; //

Java学习笔记整理——李兴华视频归纳

}

import ;

import ption;

import tream;

import putStream;

/**

* @author Administrator

*

* @description InputStream类学习测试代码

* @history

*/

public class InputStreamDemo {

/**

* @description 字节流：输入流InputStream

* @param args

* @throws IOException

*/

public static void main(String args[]) throws IOException {

// 字节流的输入流和输出流过程步骤比较固定

// 第1步、使用File类找到一个文件

File f = new File("d:" + tor + "");

// 第2步、通过子类实例化父类对象(InputStream为抽象类，本身不能直接实例化)

InputStream input = new FileInputStream(f);

// 第3步、进行读操作

byte b[] = new byte[(int)()]; // 数组大小由文件大小来确定

for (int i = 0; i < ; i++) {

}

// 3、遍历文件或者文件夹操作

File file3 = new File("d:");

// File file3 = new File("d:"+tor);

File files[] = les(); // 列出全部内容

for (int i = 0; i < ; i++) {

}

n(files[i]);

// 2、创建文件夹操作

File file2 = new File("d:helloworld");

// File file2 = new File("d:"+tor+"helloworld");

(); // 建立文件夹

if (ctory()) {

n("hello-directory"); // 判断是否是目录

}

Java学习笔记整理——李兴华视频归纳

}

}

b[i] = (byte) (); // 读取内容

}

// 第4步、关闭输出流

();

/**

* @author Administrator

*

* @description

* @history

*/

public class OutputStreamDemo {

}

/**

*@description 字节流：输出流OutputStream类

*@param args

*@throws Exception

*/

public static void main(String args[]) throws IOException {

// 输入和输出流参考的是Java程序，输出流操作步骤也比较固定

// 第1步、使用File类找到一个文件

File f = new File("d:" + tor + "");

// 第2步、通过子类实例化父类对象

OutputStream out = new FileOutputStream(f);

// 第3步、进行写操作

String str = "say hello world!!!";

byte b[] = es();

for(int i=0;i<;i++){

(b[i]); // 单个写入

}

// (b);

// 重载方法write

// public abstract void write(int b) throws IOException;

// public void write(byte b[]) throws IOException {}

// 第4步、关闭输出流

(); // 关闭输出流

}

Java学习笔记整理——李兴华视频归纳

import ;

import ption;

import ;

import ader;

/**

* @author Administrator

*

* @description 字符流：输入流Reader

* @history

*/

public class ReaderDemo {

/**

*@description 字节流和字符流按照处理数据的单位划分

*@param args

*@throws IOException IO异常处理

*/

public static void main(String args[]) throws IOException {

// 第1步、使用File类找到一个文件

File f = new File("d:" + tor + "");

// 第2步、通过子类实例化父类对象

Reader input = new FileReader(f);

// 第3步、进行读操作

char c[] = new char[1024];

int temp = 0;

int len = 0;

while ((temp = ()) != -1) {

// 如果不是-1就表示还有内容，可以继续读取

c[len] = (char) temp;

len++;

Java学习笔记整理——李兴华视频归纳

}

}

}

// 第4步、关闭输出流

();

import ;

import ption;

import ;

import iter;

/**

* @author Administrator

*

* @description

* @history

*/

public class WriterDemo {

}

import rayInputStream;

import ;

import putStream;

import tputStream;

import ption;

import tream;

import treamReader;

import StreamWriter;

import ;

/**

*@description 通过代码学习发现，基本上步骤一致的

*@param args

*@throws IOException

*/

public static void main(String args[]) throws IOException {

// 第1步、使用File类找到一个文件

File f = new File("d:" + tor + "");

// 第2步、通过子类实例化父类对象

Writer out = new FileWriter(f); // 通过对象多态性，进行实例化

// 第3步、进行写操作

String str = "nsay hellotworld";

(str);

// 第4步、关闭输出流

// (); // 清空缓冲

(); // 关闭输出流

}

Java学习笔记整理——李兴华视频归纳

import ;

public class ByteAndCharStreamTest {

}

/**

*@description 字节流：InputStream,OutputStream

* 字符流：Reader,Writer

* // 字节流和字符流相互转换测试

*@param args

* @throws IOException 文件操作异常处理

*/

public static void main(String[] args) throws IOException {

// 1、输入流-字节流转换成字符流

// 通过InputStreamReader类来进行转换

InputStream is = new FileInputStream("d:");

Reader reader = new InputStreamReader(is); // 将字节流转换成字符流

char c[] = new char[1024];

int len = (c); // 读取操作，保存在字符数组中

(); // 关闭操作

n(new String(c,0,len)); // 字符数组转换成String类实例

// 2、输出流-字节流转换成字符流

// 通过OutputStreamWriter类来进行转换

File f = new File("d:" + tor + "");

Writer out = new OutputStreamWriter(new FileOutputStream(f)); // 字节流变为("hello world!!!"); // 使用字符流输出

();

// 3、从字符流到字节流转换可以采用String类提供的操作

// 从字符流中获取char[]，转换成String实例然后再调用String API的getBytes()方法

// 接1中的代码如下，最后通过ByteArrayInputStream即可完成操作

String str = new String(c,0,len);

byte b[] = es();

InputStream is2 = new ByteArrayInputStream(b);

();

// 4、其他常见的流

// 内存操作流ByteArrayInputStream,ByteArrayOutputStream

// 管道流PipedOutputStream,PipedInputStream

// 打印流PrintStream

// 缓存流BufferedReader

字符流

// ...等等

}

Java学习笔记整理——李兴华视频归纳

字符编码学习代码

import tputStream;

import ption;

import Stream;

public class CharSetDemo {

}

对象序列化学习代码

对象序列化：将对象转换成二进制的字节流，反序列化刚好相反。

import putStream;

import tputStream;

import tream;

import InputStream;

import Stream;

import OutputStream;

import izable;

class Demo implements Serializable{ // 实现序列化接口

// 序列化方式之一，Java自身提供的序列化支持

// 其他序列化方式，待以后有需要进一步学习

private static final long serialVersionUID = 1L;

private String info; // 定义私有属性

// 如果某个属性不想被序列化，采用transient来标识

//private transient String noser;

public Demo(String info){

/**

* @description 字符编码学习测试方法

* @param args

* @throws IOException 文件IO异常处理

*/

public static void main(String[] args) throws IOException {

}

// 1、字符编码，通过system类来获取

String fe = perty("ng");

n(fe); // GBK

// 2、进行转码操作

OutputStream out = new FileOutputStream("d:");

byte b[] = "Java，你好！！！".getBytes("ISO8859-1"); // 转码操作

(b); // 保存

(); // 关闭

Java学习笔记整理——李兴华视频归纳

}

}

= info;

public String getInfo() {

}

public void setInfo(String info) {

}

public String toString() {

}

return "info = " + ;

= info;

return info;

public class SerializedDemo {

}

/**

*@description 对象序列化、反序列化操作

*@param args

*@throws Exception

*/

public static void main(String[] args) throws Exception {

}

// 1、对象序列化是将内存中的对象转换成二进制形式的数据流

// 2、对象反序列化刚好和对象序列化方向相反，将二进制数据流转换成对象

// a、对象序列化采用ObjectOutputStream类

ObjectOutputStream oos = null; // 声明对象输出流

OutputStream out = new FileOutputStream("d:");

oos = new ObjectOutputStream(out);

bject(new Demo("helloworld"));

();

// b、对象反序列化采用ObjectInputStream类

ObjectInputStream ois = null; // 声明对象输入流

InputStream input = new FileInputStream("d:");

ois = new ObjectInputStream(input); // 实例化对象输入流

Object obj = ject(); // 读取对象

();

n(obj);

二、Java类集合框架

比较详细的笔记：

/view/

一个思考题目：如何实现一个stack，使得增加、删除、获取最大值、最小值以及中值的时间操作效率相当。

/**

Java学习笔记整理——李兴华视频归纳

* @author Administrator

*

* @description 如何从java类集框架中选取适当的数据结构呢???

* @history

*/

public interface Stack {

public void add(T t); // 添加元素

public void delete(T t); // 删除元素

public T getMax(); // 获取最大值

public T getMin(); // 获取最小值

public T getMiddle(); // 获取第中间大值

}