Java 笔记

1 词语

JRE —— Java运行时环境（Java Runtime Environment）

JVM —— Java虚拟机

JDT —— Java的开发环境，可以方便的对代码进行开发及调试功能

SDK —— 软件开发工具包（Software Development Kit）

IDE —— 集成开发环境（Integrated Development Environment）

2 classpath的指定

Java中有两个重要属性(两个重要的环境变量)

path —— 所有的 java 命令的存放路径
classpath —— 类的路径

classpath的配置方法：

//注意等号的两边不能有空格
set classpath=路径1;路径2;...//example
set classpath=D:\testjava\basic//默认的设置
set classpath=.

3 java的编译和解释

源程序（*.java）经过编译程序（javac.exe）转换为字节码（ByteCode），交由虚拟机解释执行。

虚拟机将每一条要执行的字节码送给解释器（java.exe），解释器将字节码翻译成特定机器上的机器码。

4 .Something

1 java文件的文件名注意大小写

2 布尔类型不能转换成其他类型

3 switch语句中case后面的选择值只能是字符或常量

4 输出到控制台System.out.print()

5 String的比较，使用equals()方法，如 if(str1.equals(st2))

6 类的属性 = 字段 = 成员变量

7 计算开方 Math.sqrt(double a);

8 Java不支持全局变量和方法

5. 关键字

assert 是在 JDK 1.4 之后增加的。

enum 是在 JDK 1.5 之后增加的。

6. Eclipse快捷键

自动排版 —— Ctrl + Shift + F

自动补全 —— Ctrl + Alt + /

显示建议 —— Alt + /

注释当前行 —— Ctrl + /

运行 —— Alt + Shift + X

7. 数据类型

数据类型	字节
byte	1
short	2
int	4
long	8
float	4
double	8
char	2
boolean	1位

查看某数据类型可表示的最大值：

byte —— Byte.MAX_VALUE

short —— Short.MAX_VALUE

int —— java.lang.Integer.MAX_VALUE

long —— java.lang.Long.MAX_VALUE

8. 转义字符

转义字符	含义
\f	换页
\b	倒退一格
\r	归位
\t	跳格

9. 运算符

~	取补码

10. 数组

1 一维数组的声明与内存分配

// way 1
int score[];
score = new int[3];// way 2
int score[] = new int[3];// way 3
int score[] = {80,90,95};

在上面的例子中，score中所保存的并非是数组的实体，而是数组实体的参考地址。

二维数组的声明与之类似，将[]改为[][]。

二维数组的每一行元素可以不相同

2 取得数组a的长度：a.length

对于二维数组，a.length表示行数，a[1].length表示第2行元素的个数

3 数组拷贝

System.arraycopy(a1, 1, a2, 2, 3);//将a1中1号下标开始的3个单元拷贝到a2中2号下标开始的位置

4 数组排序

import java.util.*;
......
int a[];
......
Arrays.sort(a); //排序
......

5 数组可以直接作为返回值进行返回

11. 类和对象

1 声明

//对象的声明
// way 1
Person p;
p = new Person();// way 2
Person p = new Person();

2 比较

"=="比较的只是两个地址

3 类变量和成员变量

区别在于：类变量就是 static 修饰的变量，是 静态变量 ，它们被类的实例所共享，就是说一个实例改变了这个值，其他的实例也会受到影响；成员变量则是 非静态变量 ，是实例所私有的，只有实例本身可以改变它的值。

4 Java不支持多继承，即一个类只能继承一个类而不能继承多个类。

// 继承的语法
class 父类
{}class 子类 extends 父类
{}

5 父类中的私有属性和方法（private）不可直接被子类访问到

6 无论方法（包括构造方法）是否被覆写，都可以通过super关键字进行访问。

7 向上转向与向下转型

可以用子类的构造函数去实例化父类的对象，此时就是对象的向上转型。向上转型不需要进行强制类型转换，但是会丢失精度。

父类的对象可以转换为子类的对象，但是必须要进行强制的类型转换。

class Person{}
class Student extends Person{}// 错误的用法
Person p = new Person();
Student s = (Student)p;// 错误的用法
Person p = new Student();
Student s = p;// 正确的用法
Person p = new Student();
Student s = (Student)p;

8 抽象类

定义抽象类和抽象方法的关键字是 abstract 。抽象方法无函数体。

在抽象类中声明含有参数的构造方法后，在子类中必须明确调用。

//抽象类
abstract class A//抽象方法
public abstract void talk();

9 接口

数据成员必须初始化，均为常量，方法全部声明abstract（可省略abstract关键字）。

一个类可以实现多个接口，是Java实现多继承的一种机制。

接口的继承关键字也是 extends 。一个接口可以继承多可接口。

// 接口声明时的关键字为interface
interface Person{final int i = 1; 		//final是可省的abstract public void fun1();	//abstract是可省的
}interface Person2{int i = 2;public void fun2();
}// 接口扩展（继承）关键字为extends
interface Person3 extends Person, Person2{int i = 3;public void fun3();
}// 接口实现时的关键字为implements
class Student implements Person3{public void fun1(){System.out.println("1");}public void fun2(){System.out.println("2");}public void fun3(){System.out.println("3");}public void talk(){System.out.println(i);}
}public class HelloWorld2 {	public static void main(String[] args) {Person p = new Student();Student s = (Student)p;s.talk();}
}// 运行结果：
3

12 Object类

1 Object类中含有一个String toString()方法。当打印对象时被自动调用。若不覆写此方法，则会打印出类似 Person@c17164 之类的无序字符串。

class Person{String name = "张三";int age = 25;public String toString(){System.out.println("There is toString!");return "Hello!";}
}public class HelloWorld2 {public static void main(String[] args) {Person p = new Person();System.out.println(p);}
}//运行结果：
There is toString!
Hello!

2 另一个需要覆写的方法是 equals

13 内部类

Java中的类可以嵌套定义，此时称为内部类与外部类。内部类可声明成public或private，此时对它的访问的限制于成员变量和成员方法完全相同。

内部类可以直接调用外部类中的属性，而外部类不能找到内部类中所声明的属性。

用static声明的内部类就变成了外部类，但是用static声明的内部类不能访问非static的外部类属性。

在类外部可以引用内部类，但是要将内部类声明为public。

// 在类外部引用内部类
class Outer{int score = 25;public class Inner{void display(){System.out.println(score);}}
}public class HelloWorld2 {public static void main(String[] args) {Outer outer = new Outer();	//首先要有一个外部类的实例Outer.Inner inner = outer.new Inner();inner.display();}
}

在方法中也可以定义内部类，但是它只能访问方法中的final类型的局部变量。（为什么？？？？）

14 匿名内部类

例子：

interface A {public void fun1();
}class B {int i = 10;class C implements A {public void fun1() {System.out.println(i);}}public void get(A a) {a.fun1();}public void test() {this.get(new A() {public void fun1() {System.out.println(i);}});}
}public class HelloWorld2 {public static void main(String[] args) {B b = new B();b.test();}
}

在上面的例子中，get(new A())的作用是传递一个A的匿名对象，之后实现A接口里的fun1方法。这里把实现方法的语句写到了参数的位置上，紧接在new A()之后，阅读时要注意小括号和花括号的区别。

15 匿名对象

例子：

System.out.println(new Person().talk());

这里可以看到，用new Person()声明的对象并没有赋给任何一个Person类对象的引用，所以此对象只使用了一次，之后就被Java的垃圾收集器回收。

16 instanceof

instanceof 是Java的一个二元操作符，和==，>，<是同一类东西。由于它是由字母组成的，所以也是Java的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。可以用在继承中的子类的实例是否为父类的实现。相当于c#中的is操作符。

instanceof 一般情况下用在对象类型的强制转换。如

//继承关系 class Manager extends Employee
//----------------------------------------------------------
public void doSomething(Employee e) {if ( e instanceOf Manager){Manager m = (Manager) e ;}
}

17 全局常量

声明方法：public static final

18 常用类库

1 String类和StringBuffer类

当字符串的内容需要频繁改变时，需要考虑使用StringBuffer类实现，因为其内容可以改变，所以执行性能会比String类更高。

//以下两种方法在编译时是等效的。
String x = "a" + 4 + "c";
String x = new StringBuffer().append("a").append(4).append("c").toString();

2 使用包装类进行String to Int(float、long..)

String a = "123";
int i = Integer.parselInt(a);

3 System类

System类中的所有成员都是静态的。

exit(int status) 终止虚拟机的运行。0表示正常终止，非0值表示异常终止。

CurrentTimeMillis() 获得自1970.1.1 00：00：00以来的毫秒数。

getProperties() 用于获得当前虚拟机的环境属性。

// 打印当前虚拟机的所有与环境属性的变量和值
Properties sp = System.getProperties();
Enumeration e = sp.propertyNames();
while(e.hasMoreElements())
{String key = (String)e.nextElement();System.out.println(key + "\t = \t" + sp.getProperty(key));
}

4 Runtime类

Runtime类封装了Java命令本身的运行进程。可以通过静态方法Runtime.getRuntime获得正在运行的Runtime对象的引用。

//启动一个新的进程
Runtime run = Runtime.getRuntime();
try
{Process pro = run.exec("notepad2.exe");
}
catch(Exception e)
{e.printStackTrace();
}

5 Date、Calendar、DateFormat

Calendar.add() 增加时间

Calendar.get() 取出某些字段

Calendar.set() 修改某些字段

Calendar.getInstance() 返回一个Calendar对象实例

Calendar c1=Calendar.getInstance();
//获得当前年月日的值的方法
int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1;
int date = c.get(Calendar.DATE);// 下面打印当前时间
System.out.println(c1.get(c1.YEAR)+"年"+(c1.get(c1.MONTH)+1)+"月"+c1.get(c1.DAY_OF_MONTH)+"日"+c1.get(c1.HOUR)+":"+c1.get(c1.MINUTE) +":"+c1.get(c1.SECOND));// 增加天数为230
c1.add(c1.DAY_OF_YEAR,230);

DateFormat用于日期的格式化输入输出

SimpleDateFormat sp1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss") ;
SimpleDateFormat sp2 = new SimpleDateFormat("yyyy年MM月dd日 hh点mm分ss秒") ;
try 
{Date d = sp1.parse("2005-8-11 18:30:38") ;	//格式化输入String st = sp2.format(d);		//格式化输出System.out.println(st) ;
}
catch (ParseException e) 
{e.printStackTrace();
}

6 Random

产生随机数。在Random的构造方法中已经用当前时间进行了初始化。

//产生一个100以内的随机数
Random r = new Random() ;
int a = r.nextInt(100);

7 对象克隆与比较器的实现

对象克隆，需要实现Cloneable接口，改写Object类中的clone()方法

数组比较，需要实现Compareable接口，指定泛型为类名，改写compareTo()方法

13.2 13.4的视频

转载于:https://www.cnblogs.com/toybrick/archive/2012/01/16/2323975.html