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的视频
浙公网安备 33010602011771号