本文仅作为我个人学习笔记使用，内容杂乱无章，想学习Java的小伙伴可以不用看这篇博客了，免得浪费时间…
标识符与数组
标识符
Java中的标识符由字母、数字、下划线和美元符号组成，长度不受限制，但是不能是关键字或true、false和null，并且不能以数字开头。
Java使用Unicode标准字符集，上面所说的字母不仅仅包含通常的拉丁字母abc等，还包括中文中的汉字、日文的片假名和平假名、朝鲜文、俄文、希腊字母以及其他许多语言中的文字。例如int 上海 = 1; double 北京 = 2; boolean 正确 = true; boolean 错误 = false;
等都是正确的命名方法。
数组
声明数组
声明一维数组有下列两种方式：
数组元素类型 数组名[];
数组元素类型[] 数组名;
声明二维数组有下列两种方式：
数组元素类型 数组名[][];
数组元素类型[][] 数组名;
与C++不同的是，Java不允许在声明数组中的方括号内指定数组元素的个数，例如一下的语句是错误的：
int a[12];
int[12] a;
为数组分配元素
声明数组只是给出了数组变量的名字和元素类型，但是还没有给数组分配元素。给数组分配元素的格式如下：
数组名 = new 数组元素类型[数组元素个数];
在Java中，允许使用变量指定数组元素个数。
Java采用"数组的数组"声明多维数组，一个二维数组是由若干个一维数组组成，以此类推。同时，构成二维数组的一维数组的长度可以不相同，在创建二维数组时可以分别指定构成该二维数组的一维数组的长度，例如：
int[][] a = new int[3][]; //int[][] a = new int[][];是错误的
a[0] = new int[3];
a[1] = new int[12];
a[2] = new int[13];
使用数组元素
一维数组通过索引访问自己的元素，下标从0开始。如果索引越界，程序在编译时可以通过，但是在运行时将发生ArrayIndexOutOfBountdsException异常。二维数组也通过索引访问自己的元素。例如，声明并创建了一个二维数组：
int[][] a = new int[6][8];
那么第二维的索引范围只能是0-7，如果有这样的语句
a[0][8] = 10;
那么运行时将会发生异常。而不会像C++那样使得a[1][0] = 10。
访问权限修饰符
访问权限修饰符种类
Java中的权限修饰符有三个，分别是public、protected和private。除此之外，若不加上述的三个修饰符，那么类、变量、方法的权限就是默认的。
使用权限修饰符修饰类
在Java中，不能使用private和protected来修饰类，也就是说，类只有两种权限：public和默认。
| 权限 | 在同一个包中的类 | 在不同的包中的类 |
|---|---|---|
| private | 可以直接使用该类 | 需要通过import语句或类的全名(“包名.类”)来使用该类 |
| 默认 | 可以直接使用该类 | 不可见 |
使用权限修饰符修饰变量和方法
可以使用三种权限修饰符中的任意一种来修饰变量和方法，但是如果希望变量或方法是friendly的，不能显式写出friendly，只需要不加任何修饰符就好了。
| 权限修饰符 | private | 默认 | protected | public |
|---|---|---|---|---|
| 同一个类 | √ | √ | √ | √ |
| 同一个包中的不同类(以及子类) | √ | √ | √ | |
| 不同包中的子类 | √ | √ | ||
| 不同包中的其他类 | √ |
对象的上转型对象
上转型对象对于变量和方法的访问
对象的上转型对象的实体是由子类创建的，但是上转型对象会失去其子类所拥有的一些属性和功能。
上转型对象具有如下特点：
- 关于子类新增的成员变量和方法
上转型对象不能操作子类新增的成员变量（失去了这部分属性），不能调用子类新增的方法（失去了这部分行为）。 - 关于子类继承的成员变量和方法
上转型对象可以访问子类继承的成员变量和方法。 - 关于子类隐藏的成员变量和重写的方法
- 对于被子类隐藏了的成员变量，上转型对象是无法访问的，它只能访问子类中同名的那个成员变量。
- 而对于被子类重写的实例方法，上转型对象是无法调用的，它只能调用重写之后的实例方法。
- 至于类方法，无论是否被子类重写，上转型对象都只能使用父类的类方法。
也就是说，对于被子类改变了的变量和方法，只有实例方法会使用子类的，除此之外的类变量、成员变量和类方法都是使用父类的。
由于对于我来说第三点比较难以记忆，所以下面写了个例子方便理解。
class Father {
static String str = new String("father's class variable.");
static void smethod() {
System.out.println("father's class method");
}
String s = new String("father's member variable");
void method() {
System.out.println("father's instance method");
}
}
class Son extends Father{
static String str = new String("son's class variable");
static void smethod() {
System.out.println("son's class method");
}
String s = new String("son's member variable");
void method() {
System.out.println("son's instance method");
}
}
public class Temp {
public static void main(String[] args) {
Father f = new Son();
System.out.println(f.str);
System.out.println(f.s);
f.smethod();
f.method();
}
}
运行结果
father'sclass variable.
father'smember variable
father'sclass method
son’s instance method
从结果中可以看出，对于被子类改变了的变量和方法，只有实例方法会使用子类的，除此之外的类变量、成员变量和类方法都是使用父类的。
abstract类和abstract方法
abstract类和方法
使用关键字abstract修饰的类称为abstract类（抽象类），用关键字abstract修饰的方法称为abstract方法（抽象方法）。对于抽象方法，只允许声明，不允许实现（即没有方法体）。
abstract类和方法的特点
- abstract不允许和final、static、private中的任何一个关键字同时来修饰一个方法。
- abstract类中可以有abstract方法，也可以有非abstract方法；但是非abstract类中只能有非abstract方法。
- abstract类不能用new运算符创建对象。
- 如果一个非abstract类是abstract类的子类，那么它必须重写父类的abstract方法。如果一个abstract类是abstract类的子类，那么它可以继承父类的方法，也可以重写父类的方法。
接口
接口特点
使用关键字interface来定义一个接口。接口的定义包含接口声明和接口体，定义接口时使用interface来声明自己是一个接口。接口体中只包含两个部分：常量声明(没有变量)和抽象方法。
接口中所有的常量访问权限均为public，而且是static常量，并且还是final的。但是在声明的时候允许省略public、static和final这三个关键字。
接口体中所有的抽象方法的访问权限一定都是public，在声明时允许省略public abstract修饰符。
abstract类和接口的比较
abstract类和接口的比较如下：
- abstract类中可以有abstract方法也可以有非abstract方法，但是接口中只能有abstract方法
- abstract类中可以有变量也可以有常量，但是接口中只能有常量
- 一个类只能直接继承自一个abstract类，但是可以实现多个接口。接口在要求一些类有相同名称的方法的同时，并不强迫这些类具有相同的父类。
内部类和异常类
内部类
Java支持在一个类中声明另一个类，这样的类称为内部类，而包含该内部类的类称为该内部类的外嵌类。
内部类和外嵌类的关系
- 外嵌类的成员变量在内部类中任然有效。
- 外嵌类的方法可以被内部类中的方法调用。
- 内部类不能声明类变量和类方法。
- 内部类仅供它的外嵌类使用，其他类不能用某个类的内部类声明对象。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。
- 内部类可以被修饰为static类(非内部类不能修饰为static类)，这样就可以在其他类中使用static内部类来创建对象了。
关于第二点，例子如下
public class UseOutMethod {
public void speak() {
System.out.println("外部类的方法");
}
class Inner {
public void innerSpeak() {
System.out.println("在内部类中调用外部类的方法");
speak();
}
}
Inner in = new Inner();
public static void main(String[] args) {
UseOutMethod u = new UseOutMethod();
u.in.innerSpeak();
}
}
输出如下
在内部类中调用外部类的方法
外部类的方法
匿名类
如果没有显示声明一个类的子类，但是想用子类创建一个对象，就可以使用匿名类来达成这一目的。
假设A是一个类，以下代码就创建了A的一个匿名子类：
new A() {
//类体
};
匿名类特点如下：
- 匿名类可以继承父亲的方法也可以重写父亲的方法。
- 使用匿名类时，必然是在某个类中直接使用匿名类创建对象，因此匿名类一定是内部类。
- 由于匿名类是一个子类，但是没有类名，所以在用匿名类创建对象时，要直接使用父类的构造方法。
下面是一个匿名类的例子：
abstract class OutputAlphabet {
public abstract void output();
}
public class OutputEnglish extends OutputAlphabet {
public void output() {
for(char c = 'a'; c <= 'z'; c++) {
System.out.printf("%3c", c);
}
System.out.println();
}
}
public class ShowBoard {
void showMess(OutputAlphabet show) {
show.output();
}
}
public class Example7_2 {
public static void main(String[] args) {
ShowBoard board = new ShowBoard();
board.showMess(new OutputEnglish());
board.showMess(new OutputAlphabet() {
public void output() {
for(char c = 'α'; c <= 'α' + 24; c++) {
System.out.printf("%3c", c);
}
System.out.println();
}
});
}
}
输出如下
a b c d e f g h i j k l m n o p q r s t u v w x y z
α β γ δ ε ζ η θ ι κ λ μ ν ξ ο π ρ ς σ τ υ φ χ ψ ω
Java也允许直接使用接口名和一个类体创建一个匿名类。若A是一个接口，那么如下方法可以创建一个匿名类：
new A {
//类体
};
异常
有关异常的关键字:try catch throw throws finally
Java正则表达式
目前我会的Matcher类的方法
boolean matches()
int find()
int start()
int end()
Matcher reset()
String group(int group)
boolean lookingAt()
String replaceAll(String replacement)
String replaceFirst(String replacement)
Matcher appendReplacement(StringBuffer sb, String replacement)
StringBuffer appendTail(StringBuffer sb)
扫一扫
370
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
