java知识点（1）
知识点
1.标识符
java 标识符可以是 字母、数字、$、_(下划线)，不可用数字开头，不能是java 的关键字。
2.命名规则
| 名 | 规则 | 例子 |
|---|---|---|
| 包名 | 全部小写 | multiplicationtable） |
| 类名 | 每个单词的首字母大写 | MultiplicationTable |
| 变量名 | 第一个字母小写，以后每个单词的首字母大写 | multiplicationTable |
| 常量 | 全部使用大写字母，单词间用下划线隔开 | MULTIPLICATION_TABLE |
3.等等号（==）和equals的区别
| == | equals |
|---|---|
| 两个变量的值是否相等,对于引用型变量表示的是两个变量在堆中存储的地址是否相同 | 两个变量是否是对同一个对象的引用 |
| 即栈中的内容是否相同（栈中存自动变量，即局部变量） | 即堆中的内容是否相同（堆中存对象和静态（static）变量） |
| 比较的是2个对象的地址 | 比较的是2个对象的内容 |
s1=new String("student");
s2="student";
s3="student";
s4=new String(s2);
s1==s2: false
s1.equals(s2): true
s1==s4: false(地址不同)
s1.equals(s4): true(内容相同)
s2==s3: true
s2.equals(s3): true
s3==s4: false
s3.equals(s4): true
s2="student";
s3="student";
这两个是相同的,指向常量池中的"student"。
s1=new String("student");
s4=new String(s1);
这两个是不同的对象,尽管他们的内容是一样。
显然，当equals为true时，==不一定为true（内容equals的，地址不一定==）。4.switch
当switch里面没有break语句时，它会一直判断下去。
例：下列输出结果是（ C ）
int a = 0
while ( a < 5 ) {
switch(a){
case 0:
case 3 : a = a + 2;
case 1 :
case 2 : a = a + 3;
default : a = a + 5;
}
}
System.out.print ( a )
A、 0
B、 5
C、 10
D、 其他 5.for
for循环可以用于循环次数不确定的情况，比如：死循环
for(;1;)
{
}6.自动类型转换
（1）数据类型
*基本数据类型：
boolean, byte, char, short, int, long, float, double, void.
×这些类型的封装类：
Boolean, Byte, Character, Short, Integer, Long, Float, Double, Void
（2）基本数据类型转换遵循的原则：
* 数据类型容量大小排序：byte,short,char
7.运算符优先级别
8.局部变量的作用范围
局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中
9. String 和 StringBuffer
StringBuffer对象比String对象的操作效率要高
| String | stringbuffer |
|---|---|
| 用String存储字符串时，如果追加字符串，它会在内存中重新开辟一块空间来存储 | 用StringBuffer时，它会在原来的基础上继续追加字符串，不会开辟新的内存空间 |
| 对String修改时，它都会创建一个新的对象并指向它，创建对象多了，垃圾回收就多了，垃圾回收也涉及到一部分时间 | 对StringBuffer修改都是对该对象进行修改 |
StringBuffer的初始化
通常情况下一般使用构造方法进行初始化:
//StringBuffer对象为空对象。
StringBuffer s = new StringBuffer();
//StringBuffer对象的内容为字符串”abc”。
StringBuffer s = new StringBuffer(“abc”);StringBuffer和String属于不同的类型
不能直接进行强制类型转换
StringBuffer s = “abc”; //错误，赋值类型不匹配
StringBuffer s = (StringBuffer)”abc”;//错误，不存在继承关系，无法进行强转StringBuffer对象和String对象之间互转
String转换为StringBuffer：
String s = “abc”;
StringBuffer sb2 = new StringBuffer(s);StringBuffer转换为String
StringBuffer sb1 = new StringBuffer(“123”);
String s1 = sb1.toString();
Java 字符串常用操作（String类）
- 1.字符串查找
indexOf（String s）
返回字符(串)s在指定字符串中第一次出现的索引位置，找不到则返回-1。lastIndexOf(String s)
返回字符(串)s在指定字符串中最后一次出现的索引位置，找不到则返回-1。
String str ="We are students";
int size1=str.indexOf('a'); //3
int size2=str.indexOf("a"); //3
int size3=str.indexOf("ar"); //3
int size4=str.indexOf("p"); //-1
//空格也占一个索引位置- 2.获取指定索引位置的字符
charAt()返回指定索引处的字符串。
String str = "hello word";
char mychar1 = str.charAt(4); //o
char mychar2 = str.charAt(5); //(不返回任何东西)
char mychar3 = str.charAt(6); //w
//空格也占一个索引位置- 3.获取子字符串
substring(int beginIndex)返回从指定的索引位置一直到该字符串结尾的子串。substring(int beginIndex, int endIndex)返回从指定的开始位置索引到指定的结束位置索引的子字符串。（“包头不包尾”）
String str="I love my husband,who called FengWenhua.";
String myString1=str.substring(7); //my husband,who called FengWenhua.
String myString2=str.substring(0, 17); //I love my husband- 4.去除空格
trim()返回字符串的副本，忽略前导空格和尾部空格。
String str=" 老公生病了，我吃饭都没胃口了。 ";
System.out.println("唉~,"+str.trim()+"老公快点好起来！");//唉~,老公生病了，我吃饭都没胃口了。老公快点好起来！
System.out.println("唉~,"+str+"老公快点好起来！");//唉~, 老公生病了，我吃饭都没胃口了。 老公快点好起来！- 5.字符串替换
replace(oldChar,newChar)将指定的字符或字符串替换成新的字符或字符串
String str= "address";
String newstr1 = str.replace("a", "A"); //Address
String newstr2=str.replace(str, "My Home"); //My Home6.判断字符串的开始与结尾
startsWith(String prefix)判断当前字符串对象的前缀是否是参数指定的字符串endsWith(String suffix)判断当前字符串是否以给定的子字符串结束
7.判断字符串是否相等
equals(String otherstr)两个字符串具有相同的字符和长度时，返回true。equals()方法区分大小写。equalsIgnoreCase(String otherstr)忽略大小写。
8.按字典顺序比较两个字符串
str.compareTo(String otherstr);- 该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。
- 此String对象位于参数字符串之前，则比较结果为一个负整数；位于参数字符串之后，则比较结果为一个正整数；若两个字符串相等，则结果为0.
9.字母大小写转换
toLowerCase()将字符串中的所有字符从大写字母改写为小写字母tuUpperCase()将字符串中的小写字母改写为大写字母
String str= "aDDreSs";
lower=str.toLowerCase();//address
upper=str.toUpperCase();//ADDRESS- 10.字符串分割
- 使字符串按指定的分隔字符或字符串对内容进行分割，并将分割后的结果存放在字符数组中。
split(String sign)sign为分割字符串的分割符，也可以使用正则表达式。str.split(String sign, in limit)；根据给定的分割符对字符串进行拆分，并限定拆分的次数。- 对某些特殊字符，如：| , + , * , ^ , $ , / , | , [ , ] , ( , ) , - , . , \等, 因为它们正好是正则的一部分，所以如果用该字符本身来作为切割处的标志, 这些字符需要进行转义。
- 例如: 想用 | 竖线去分割某字符，需要 \ 去转义。因转义使用 , 这个 \ 正好是正则表达式的字符，所以还得用一个 \ 。所以需要 \。
String str="1234@abc#hhh";
String[] a = str.split("@|#");
System.out.println("结果: "+a[0]+","+a[1]+","+a[2]); //结果: 1234,abc,hhh
String str="1234@abc#hhh";
String[] a = str.split("@");
System.out.println("结果: "+a[0]+","+a[1]);//结果: 1234,abc#hhh
String str="1234@abc#hhh@www@lll";
String[] a = str.split("@",2);
System.out.println("结果: "+a[0]+","+a[1]); //
String str="1234@abc#hhh@www@lll";
String[] a = str.split("@",2);
System.out.println("结果: "+a[0]+","+a[1]+","+a[2]); //报错String str="5678|XYZ";
String[] b = str.split("\\|"); //注意这里用两个 \\，而不是一个\
System.out.println("结果: "+b[0]+","+b[1]);//结果：5678,XYZString str="5678|XYZ";
String[] b = str.split("|"); //注意直接使用|，该字符是正则表达式的一部分，
String x="结果: ";
for(int i=0;i",";
}
System.out.println(x); //结果: 5,6,7,8,|,X,Y,Z, 10.数组的定义和初始化
- 数组本身是一个对象。
一维数组
定义（以int型数组为例）
- 方式一：
int[] arr; - 方式二：
int arr[];
- 方式一：
数组的初始化
| 静态初始化 | 动态初始化 |
|---|---|
| 在定义的同时指定数组元素内容 | 在定义时先通过new 关键字开辟指定大小的存储空间，再为数组指定内容 |
方式一：int[] arr={2,5,7,4,6};方式二： int[] arr2=new int[]{2,4,6,8,10}; |
方式一：int[] arr=new int[5];//默认各元素为0方式二： int[] arr;//声明数组arr=new int[5];//为数组开辟空间建议用方式二，提高代码执行效率 |
* 一旦使用new关键字那么肯定在内存中为数组分配了空间，则必然数组有默认值。数组是对象数据类型。
//静态初始化，不指定数组长度，值写死。
//方式一：
int[] arr1={1,3,5,7,9}; //初始化为给定值。
//方式二；
int[] arr2=new int[]{2,4,6,8,10};
//动态初始化，要制定数组长度，可以在后来慢慢给它赋值。
//方式一：
int[] arr3=new int[5]; //初始化为默认值，int型为0。
//方式二；
int[] arr4=null;
arr4=new int[5];
//赋值：
for(int i=0;i<5;i++){
arr4[i]=2*i+1;
}| 错误写法 | 解析 |
|---|---|
| int intErrorArray5[] = new int[3]{50,51,52}; | 错误,静态初始化不能指定元素个数 |
| int intErrorArray6[] = new int[]; | 错误,动态初始化必须指定元素个数 |
| int[] a; a={1,2,3,4,5}; |
错误,数组常量只能在初始化操作中使用，如int[] a={1,2,3,4,5}; |
| int a[]; a[0]=1; a[1]=2; |
错误,因为数组没有初始化,不能赋值 |
二维数组
- 定义
- 方式一：int[][] arr;
- 方式二：int arr[][];
| 初始化 | 分析 |
|---|---|
| int[][] a; | 声明,没有初始化 |
| int[][] a=new int[2][3]; | 初始化为默认值,int型为0 |
| int[][] a={{1,2},{2,3},{3,4}}; int[][] a={{1,2},{2,3},{3,4,5}}; |
//初始化为给定值 //数组空间不是连续分配的，所以不要求每一维的大小相同 |
| int[][] a=new int[2][]; a[0]=new int[3]; a[1]=new int[4]; |
//a[0]其实就是一个数组 //每一维的大小可以不一样; |
| int[][] a=new int[][]{{1,2},{2,3},{3,4,5}}; | 同int[][] a={{1,2},{2,3},{3,4,5}}; |
| 错误写法 | 解析 |
|---|---|
| int[] a=new int[5]{{1,2},{2,3},{3,4,5}}; | //错误,如果提供了数组初始化操作，则不能定义维表达式 |
| int[][] a=newint[2][]; a[0]={1,2,3,4,5}; |
//错误,数组常量只能在初始化操作中使用 |
| int[][] a=new int[2][]; a[0][1]=1; |
//错误,第二维没有初始化,不能赋值,Java.lang.NullPointerException异常 |
- 总结:
- 二维就是数组的数组,里面的数组大小不要求一样
- 不管一维还是二维,在使用前(赋值,访问)必须初始化,可以用new默认初始化,也可以用数组常量初始化
- 动态初始化：数组定义与为数组分配空间和赋值的操作分开进行；
- 静态初始化：在定义数字的同时就为数组元素分配空间并赋值；
- 默认初始化：数组是引用类型，它的元素相当于类的成员变量，因此数组分配空间后，每个元素也被按照成员变量的规则被隐士初始化。
11.构造方法
- java中的构造方法是用来初始化一个对象的，并为为实例变量赋予合适的初始值。因此构造方法不需要返回类型。
- 必须满足以下语法规则：
- 方法名必须与类名相同；
- 不要声明返回类型；
- 不能被static、final、synchronized、abstract和native修饰；
- 构造方法不能被子类继承，所以用final和abstract修饰没有意义。
12.super关键字
（1）selectrubric包目录下的Chinese.java
package selectrubric;
class Person {//前面用public修飾會報錯
Person() {
System.out.println("父类、无参");
}
Person(String name) {
System.out.println("父类、有参： " + name);
}
}
public class Chinese extends Person {//因為創建的是Chinese.java,所以前面要用public class作為標誌
Chinese() {
super(); // 子类调用父类无形参的构造函数（子类的构造函数调用另一个类的构造函数时，super（）；一定要写在调用的构造函数的第一行）；
System.out.println("子类、无参");
}
Chinese(String name) {
super(name); // 调用父类具有相同形参的构造方法；
System.out.println("子类、有参： " + name);
}
Chinese(int age, String name) {// 构造方法的重载！
this(name); // this：调用当前具有相同形参的构造方法.并且，当子类没有刻意用super();调用父类的构造方法的时候，系统默认的为它调用父类中无参的构造方法；
System.out.println("子类特有： " + age);
}
public static void main(String[] args) {
Chinese chinese = new Chinese();
System.out.println("");
chinese = new Chinese("小丁");
System.out.println("");
chinese = new Chinese(35, "小丁");
}
}
/*
Chinese chinese = new Chinese();
父类、无参
子类、无参
chinese = new Chinese("小丁");
父类、有参： 小丁
子类、有参： 小丁
chinese = new Chinese(35, "小丁");
父类、有参： 小丁
子类、有参： 小丁
子类特有： 35
*/
（2）继承中的构造方法总结:
* 子类在自己的构造方法中使用super(argument_list)调用父类的构造方法。
* super()方法必须写在子类构造方法的第一行；
* 使用this(argument_list)调用当前类的另外的构造方法；
* 如果子类的构造方法中没有显式地调用父类构造方法，则系统默认调用父类中无参的构造方法；
* 如果子类构造方法中既没有显式地调用基类构造方法，而基类中没有无参的构造方法，则编译出错；
（3）子类可引用父类的某些方法和属性，通过super.xx来获取父类的变量(属性)，通过super.xx()访问父类的方法。
（4）注意：
* super()和this ()不能共存，否则编译时会报异常：Constructor call must be the first statement in a constructor。
* 换句话说就是super()和this ()都必须在构造方法的第一行。
* super(有参数/无参数) 用于调用父类相应的构造函数。
* this(有参数/无参数) 用于调用本类相应的构造函数。
13.异常
- 处理异常常用的两种方式：
- try…catch(捕获处理机制)；
- throws(冒泡处理机制).
- 注意细节：使用try…catch块捕获时可以没有catch块,但当没用catch块的时候必须得有finally块，即try能与finally单独使用。
14.接口
概念
接口:是一个抽象类型，是抽象方法的集合。一个类通过继承接口的方式，来继承接口的抽象方法。
接口并不是类，接口和类的编写方式相似，但它们是不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
接口与类相似点
- 一个接口可以有多个方法。* 接口文件保存在 .java 结尾的文件中，文件名使用接口名。* 接口的字节码文件保存在 .class 结尾的文件中。* 接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别
- 接口不能用于实例化对象。* 接口没有构造方法。* 接口中所有的方法必须是抽象方法。* 接口不能包含成员变量，除了 static 和 final 变量。* 接口不是被类继承了，而是要被类实现。* 接口支持多重继承。
接口特性
接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract，声明时同样不需要abstract关键子。（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
接口中的方法都是公有的。
抽象类和接口的区别
抽象类中的方法可以有方法体（即实现方法的具体功能），接口不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，却可以实现多个接口。
接口的声明
- 格式：NameOfInterface.java
/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包
public interface NameOfInterface
{
//任何类型 final, static 字段
//抽象方法
}- 实例：Animal.java
/* 文件名 : Animal.java */
interface Animal {
public void eat();
public void travel();
}接口的实现:implements
*实现接口的语法
...implements 接口名称[, 其他接口, 其他接口..., ...] ...- 实例:MammalInt.java
/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
public void eat(){
System.out.println("Mammal eats");
}
public void travel(){
System.out.println("Mammal travels");
}
public int noOfLegs(){
return 0;
}
public static void main(String args[]){
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
如果实现接口的类是抽象类，那么就没必要实现该接口的方法。
接口的继承:extends
一个接口能继承另一个接口
实例：Sports接口被Hockey和Football接口继承。
Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法。
实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。
接口的多重继承
public interface Hockey extends Sports, EventSports.java
public interface Sports
{
public void setHomeTeam(String name);
public void setVisitingTeam(String name);
}Football.java
public interface Football extends Sports
{
public void homeTeamScored(int points);
public void visitingTeamScored(int points);
public void endOfQuarter(int quarter);
}Hockey.java
public interface Hockey extends Sports
{
public void homeGoalScored();
public void visitingGoalScored();
public void endOfPeriod(int period);
public void overtimePeriod(int ot);
}标记接口
- 标识接口是没有任何方法和属性的接口。
- 简单来说就是来给某个对象打个标，使对象拥有某个或某些特权。
- 比如：java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义
package java.util;
public interface EventListener{}- 标记接口的目的
- 建立一个公共的父接口。使用一个标记接口来建立一组接口的父接口。
- 向一个类添加数据类型。实现标记接口的类不需要定义任何接口方法，但是该类通过多态性变成一个接口类型。
15.继承
- 一个类可以继承多个类：class A extends B，class C extends A，C就同时继承了B和A两个类。
- 但不能直接继承多个类，java是单继承语言，不支持多继承：class A extends B,C 这样写错误。
- 可以用接口来实现多继承
16.continue
- 没有标签的时候，continue的作用是忽略本次循环剩下的语句，直接进行本层循环的下一次循环，而不会结束循环。
public class Continue {
public static void main(String args[])
{
for(int i=0;i<10;i++)
{
if(i==3)
{
System.out.println("遇到continue，本次循环剩下的语句“i==3”无法执行。");
//忽略本次循环中continue剩下的语句
continue;
}
System.out.println("i=="+i);
}
}
}
/*
i==0
i==1
i==2
遇到continue，直接跳出本次循环，本次循环剩下的语句“i==3”无法执行。
i==4
i==5
i==6
i==7
i==8
i==9
*/- 带标签的continue语句的作用是跳过标签所标识循环的当次循环的剩下语句，重新开始下一次循环。
public static void main(String args[]) {
// 外层循环
outer: for (int i = 0; i < 5; i++) {
System.out.println("");
System.out.println("i==" + i);
for (int j = 0; j < 3; j++) {
System.out.println("j==" + j);
if (j == 1) {
// 忽略本次循环剩下的语句
continue outer;
}
}
}
}
}
/*
i==0
j==0
j==1
i==1
j==0
j==1
i==2
j==0
j==1
i==3
j==0
j==1
i==4
j==0
j==1
*/
------------------------------------------------------------------------------------------------------------------------------------------------------------------
public class Continue {
public static void main(String args[]) {
for (int i = 0; i < 5; i++) {
System.out.println("");
System.out.println("i==" + i);
for (int j = 0; j < 3; j++) {
System.out.println("j==" + j);
}
}
}
}
/*
i==0
j==0
j==1
j==2
i==1
j==0
j==1
j==2
i==2
j==0
j==1
j==2
i==3
j==0
j==1
j==2
i==4
j==0
j==1
j==2
*/17.Object类的方法
Object是所有类的父类，任何类都默认继承Object。
| 序号 | 方法： 说明 |
|---|---|
| 1 | clone()：保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。 |
| 2 | getClass()：返回Object 的运行时类 |
18.String类的方法
| 方法 | 说明 |
|---|---|
| regionMatches(boolean b, int firstStart, String other, int otherStart, int length) | 从firstStart位置开始取长度为length的字符,1，再从otherStart位置开始取长度为length的字符串2，两字符串比较，当b为true时字符串不区分大小写。 |
| trim() | 截去字符串两端的空格，但对于中间的空格不处理 |
| split(String str) | 将str作为分隔符进行字符串分解，分解后的字字符串在字符串数组中返回 |
| toCharArray() | 将字符串转换为字符数组 |
| contains(String str) | 判断是否包含指定的字符串 |
| getBytes() | 将字符存储在字节数组中,与getChars()用法类似。 |
| concat(String str) | concat()是将两个字符串连接在一起。 + 是将任意类型的数据连接成字符串。 |
| compareTo(String str) | 对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。 |
| compareToIgnoreCase(String str) | 对字符串内容按字典顺序进行大小比较，通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。 |
| equals(String str) | 比较当前字符串和参数字符串，在两个字符串相等的时候返回true，否则返回false |
| equalsIgnoreCase(String str) | 忽略大小写 |
| indexOf(int ch/String str) | 用于查找当前字符串中字符或子串，返回字符或子串在当前字符串中从左边起首次出现的位置，若没有出现则返回-1 |
| indexOf(int ch/String str, int fromIndex) | 从fromIndex位置向后查找 |
| lastIndexOf(int ch/String str) | 从字符串的末尾位置向前查找 |
| lastIndexOf(int ch/String str, int fromIndex) | 从fromIndex位置向前查找 |
| toLowerCase(); toUpperCase(); |
字符串中字符的大小写转换 |
| replaceFirst(String regex, String replacement) | 用字符replacement的内容替换当前字符串中遇到的第一个和字符串regex相匹配的子串，应将新的字符串返回。 |
| replaceAll(String regex, String replacement) | 用字符replacement的内容替换当前字符串中遇到的所有和字符串regex相匹配的子串，应将新的字符串返回。 |
| statWith(String prefix) | 判断是否以指定的字符串开头 |
| endWith(String suffix) | 判断是否以指定的字符串结尾 |
| (以下的方法StringBuffer也有) | ··· |
| length() | 字符串长度 |
| charAt(int Index) | 截取一个字符 |
| getChars(int sourceStart,int sourceEnd,char target[],int targetStart) | 截取多个字符。截取从位置sourceStart到位置sourceEnd的一段字符，从数组的target[]的下标值targetStart开始放入数组target[]中。target.length=sourceEnd-sourceStart。 |
| substring(int beginIndex); substring(int beginIndex, int endIndex); |
截取 |
| replace(char oldChar, char newChar) | 字符串中字符的替换 |
public class Continue {
public static void main(String args[]) {
String s = "this is a demo of the getChars method.";
char buf[] = new char[4];
s.getChars(10, 14, buf, 0);//demo
for(int i=0;iif(i==0){
System.out.print("["+buf[i]+",");
}else if(i==buf.length-1){
System.out.print(buf[i]+"]");
}else {
System.out.print(buf[i]+",");
}
}
//[d,e,m,o]
}
} //toCharArray() 将字符串转换成字符数组
String a = "123";
char buf[] = new char[3];
buf = a.toCharArray();//[1,2,3]//concat(String str) 字符串连接
String str = "aa".concat("bb").concat("cc");
//相当于String str = "aa"+"bb"+"cc";String str = "asdzxcasd";
String str1 = str.replace('a','g'); //str1 = "gsdzxcgsd"
String str2 = str.replace("asd","fgh"); //str2 = "fghzxcfgh"
String str3 = str.replaceFirst("asd","fgh"); //str3 = "fghzxcasd"
String str4 = str.replaceAll("asd","fgh"); //str4 = "fghzxcfgh"//trim()
String str = " a sd ";
String str1 = str.trim();
int a = str.length();//a = 6
int b = str1.length();//b = 4//split() 以指定的符号为标识，拆分字符串，并返回数组。
public class Continue {
public static void main(String args[]) {
String str = "asd!qwe|zx#c";
String[] str1 = str.split("!|#");
System.out.println("["+str1[0]+","+str1[1]+","+str1[2]+"] 数组长度："+str1.length);
String[] str2 = str.split("!|#|\\|");
System.out.println("["+str2[0]+","+str2[1]+","+str2[2]+","+str2[3]+"] 数组长度："+str2.length);
}
}
/*
[asd,qwe|zx,c] 数组长度：3
[asd,qwe,zx,c] 数组长度：420.StringBuffer类的方法
| 方法 | 说明 |
|---|---|
| (1)capacity() (2)StringBuffer( ) (3)StringBuffer( int len ) (4)StringBuffer( String s ) |
（1）返回整个可分配空间（即字符串缓冲区的容量） （2）分配16个字符的缓冲区 （3）分配len个字符的缓冲区 （4）除了按照s的大小分配空间外,再分配16个 字符的缓冲区，比如”abc”的长度是3另外再分配16个字符，所以一共是19。 |
| ensureCapacity(int capacity) | 设置缓冲区的大小 |
| setLength(int len) | 设置缓冲区的长度 |
| setCharAt(int where,char ch) | 用新字符取代指定位置的字符，此方法不返回任何值。 |
| append() | 可把任何类型数据的字符串表示连接到调用的StringBuffer对象的末尾 |
| insert(); StringBuffer insert(int index,String str); StringBuffer insert(int index,char ch); StringBuffer insert(int index,Object obj); |
插入字符串 |
| reverse() | 颠倒StringBuffer对象中的字符 |
| delete(int startIndex,int endIndex); deleteCharAt(int index); |
删除字符 |
| (以下方法String也有) | ··· |
| length() | 一个StringBuffer当前长度 |
| charAt(int where) | 获得指定位置的字符 |
| getChars(int sourceStart,int sourceEnd,char target[],int targetStart) | 截取多个字符。截取从位置sourceStart到位置sourceEnd的一段字符，从数组的target[]的下标值targetStart开始放入数组target[]中。 |
| substring(int startIndex); substring(int startIndex,int endIndex); |
截取子串 |
| replace(int startIndex,int endIndex,String str) | 替换 |
21.String类与基本类型的转换
| 字符串转换为基本类型 | 基本类型转换为字符串 |
|---|---|
| parseByte(String s) parseShort(String s) parseInt(String s) parseLong(String s parseFloat(String s) parseDouble(String s) |
valueOf(char data[]) valueOf(char data[], int offset, int count valueOf(boolean b) valueOf(char c) valueOf(int i) valueOf(long l) valueOf(float f) valueOf(double d) |
//字符串转换为基本数据类型
int a = Integer.parseInt("12");//12
float b = Float.parseFloat("12.34");//12.34
double c = Double.parseDouble("1.124");//1.124//基本数据类型转换为字符串
String s1 = String.valueOf(20);//20
String s2 = String.valueOf(16.98);//16.9822.进制转换
使用Long类中的方法得到整数之间的各种进制转换的方法：
* Long.toBinaryString(long l) // 转化为二进制
* Long.toOctalString(long l) // 转化为八进制
* Long.toHexString(long l) // 转化为十六进制
* Long.toString(long l, int p)//p作为任意进制
23.重载
- 重载的规则：
- 必须具有不同的参数列表；
- 可以有不同的返回类型，只要参数列表不同就可以； * 可以有不同的访问修饰符； * 可以抛出不同的异常； * 方法能够在一个类中或者在一个子类中被重载。
- 代码
public class HelloWorld
{
public HelloWorld()
{
}
public static void main(String[] argc)
{
HelloWorld w = new HelloWorld();
System.out.println(w.Multi(2,3));
System.out.println(w.Multi(2,3,4));
System.out.println(w.Multi(2.0f,3.0f));
}
public int Multi(int x, int y)
{
return x*y;
}
public int Multi(int x, int y ,int z)
{
return x*y*z;
}
public float Multi(float x, float y)
{
return x*y;
}24.实体类
- 实体类(entity)的作用一般是和数据表做映射
- 是一个拥有Set和Get方法的类
- 通常总是和数据库之类的（所谓持久层数据）联系在一起。这种联系是借由框架（如hibernate）来建立的。
- 实体类的名字尽量和数据库的表的名字对应相同。
- 应该实现java.io.Serializable接口。
- 有个无参的构造方法。
- 有个有参（所有的参数）的构造方法。
- 有属性和方法，属性对应数据库中表的字段，方法主要有getter和setter方法。
- 有个属性serialVersionUID。例如：private static final long serialVersionUID = -6125297654796395674L;
- 对象序列化机制（object serialization）:是Java语言内建的一种对象持久化方式，可以很容易的在JVM中的活动对象和字节数组（流）之间进行转换。除了可以很简单 的实现持久化之外，序列化机制的另外一个重要用途是在远程方法调用中，用来对开发人员屏蔽底层实现细节。
- 属性一般是private类型，方法为public类型，对于数据库自动生成的ID字段对应的属性的set方法为private。
- 一般格式:（私有属性，公有方法，getter 和 setter）
public class A{
private String id;
public String getId(){
return this.id;
}
public void setId(String id){
this.id = id;
}
}- 在项目中写实体类一般遵循下面的规范：
- 根据你的设计，定义一组你需要的私有属性。
- 根据这些属性，创建它们的setter和getter方法。
- 提供带参数的构造器和无参数的构造器。
- 重写父类中的eauals()方法和hashcode()方法。（如果需要涉及到两个对象之间的比较，这两个功能很重要。）
- 实现序列化并赋予其一个版本号。
- 代码
class Student implements Serializable{
/**
* 版本号
*/
private static final long serialVersionUID = 1L;
//定义的私有属性
private int id;
private String name;
private int age;
private double score;
//无参数的构造器
public Student(){
}
//有参数的构造器
public Student(int id,String name,int age, double score){
this.id = id;
this.name = name;
this.age = age;
this.score = score;
}
//创建的setter和getter方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
//由于id对于学生这个类是唯一可以标识的，所以重写了父类中的id的hashCode()和equals()方法。
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + id;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (id != other.id)
return false;
return true;
}
}25.this关键字
- 在Java语言中，当创建一个对象后，Java虚拟机就会为其分配一个指向对象本身的指针，这个指针就是“this”。
- this使用场景：
（1）使用this调用本类中的成员变量（属性）
//没有构造方法时
class Student
{
private String name;
public void setName(String name) {
this.name = name;// 将局部变量的值传递给成员变量
}
public String getName() {// 获得姓名
return "姓名：" + name;
}
}
public class Continue {
public static void main(String args[]) {
Student stu = new Student();
stu.setName("小冬");
System.out.println(stu.getName());
}
}//有构造方法时
class Student
{
private String name;
public Student(){
}
public Student(String name){
this.name=name;
}
public void setName(String name) {
this.name = name;// 将局部变量的值传递给成员变量
}
public String getName() {// 获得姓名
return "姓名：" + name;
}
}
public class Continue {
public static void main(String args[]) {
Student stu = new Student("小冬");
System.out.println(stu.getName());
}
}//姓名：小冬（2）一个类中有多个构造方法时，可用this关键字相互调用。
若代码中没有显式体现构造方法，那么编译器在编译的时候会自动添加 一个没有形式参数的构造方法。
this()调用构造方法只能放在构造方法的首行，为的是能够为类中的属性初始化；而且至少有一个构造方法是不用this调用，否则程序会出现错误。
class Student
{
private String name;
private int age;
public Student() {
System.out.println("无参");
}
public Student(String name) {
this.name=name;
System.out.println("一个参数");
}
public Student(String name, int age) {
this(name);
this.age = age;
System.out.println("两个参数");
}
public String getInfo() {
return "姓名：" + name +"\n"+"年龄：" + age;
}
}
public class Continue {
public static void main(String args[]) {
Student stu1 = new Student("小冬", 19);
System.out.println(stu1.getInfo());
}
}
/*
一个参数
两个参数
姓名：小冬
年龄：19
*/（3）使用this引用当前对象
当前对象：指当前正在调用类中方法的对象。
使用this引用当前对象：是指如果在类的方法中需要返回一个对象，并且该对象是方法所在的类的当前对象，可以使用this关键字作为方法的返回值。
package selectrubric;
class Student{
private String name ;
private int age ;
public Student(){
System.out.println("新对象实例化") ;
}
public Student (String name) {
this() ; //调用本类中的无参构造方法
System.out.println("test1");
}
public Student (String name,int age) {
this(name); //调用有一个参数的构造方法
this.age = age ;
System.out.println("test2");
}
public String getInfo(){
System.out.println("this表示调用这个方法的类："+this);
return "姓名：" + name + " 年龄：" + age ;
}
}
public class Continue{
public static void main(String args[]) {
Student stu1 = new Student ("李明",20) ; //调用构造实例化对象
System.out.println(stu1.getInfo());
}
}
/*
新对象实例化
test1
test2
this表示调用这个方法的类：selectrubric.Student@15db9742
姓名：null 年龄：20
*/class Car {
public Car getCarObject() {
return this; // 返回当前对象
}
}
public class Continue{
public static void main(String[] args) {
Car sc = new Car();// 创建一个Car对象
System.out.println(sc.getCarObject() instanceof Car);
}
}
//true（4）其它情况,比如对象的比较，可以使用this和引用传递进行两个对象是否相等的判断。思考：在哪添加一个比较的方法
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.setName(name);
this.setAge(age);
}
public void setName(String name) { // 设置姓名
this.name = name;
}
public void setAge(int age) { // 设置年龄
this.age = age;
}
public String getName() {
return this.name;
}
public int getAge() {
return this.age;
}
public boolean compare(Student stu) { // 调用此方法时里面存在两个对象：当前对象、传入的对象
Student s1 = this;// 当前的对象，就表示stu1
Student s2 = stu;// 传递进来的对象，就表示stu2
/**
* 1.地址相等，则两个对象相等；如果地址不相等，则依次判断每一个属性的内容来判断其是否相等。
* 2.String本身事一个类，必须用equals比较内容。而年龄age定义为整型，直接使用“==”即可。
*/
if (s1 == s2) {// 判断是不是同一个对象，用==比较地址。
return true;
}
if (s1.name.equals(s2.name) && s1.age == s2.age) {//判断每一个属性是否相等
return true; // 两个对象相等
} else {
return false; // 两个对象不相等
}
}
}
public class Continue {
public static void main(String args[]) {
Student stu1 = new Student("李明", 20); // 声明两个对象，内容完全相等
Student stu2 = new Student("李明", 20); // 声明两个对象，内容完全相等
// 直接在主方法中依次取得各个属性进行比较
if (stu1.compare(stu2)) {
System.out.println("两个对象相等！");
} else {
System.out.println("两个对象不相等！");
}
}
}
//两个对象相等！26.方法的声明
public void aMethod();//public是公共方法在你的这个项目里面你所有的类都能访问这个方法void aMethod();//不加的话就是默认的default 这个是只能在你当前包里才能调用这个方法
27.封装，setter,getter
- 封装就是将属性私有化，提供共有的方法访问私有属性 。
- 属性的访问方法包括setter方法和getter方法 。
- setter方法用于赋值，getter方法用于取值。
27.布局，容器对象
- BorderLayout是边框布局，它是窗体的默认布局。
- FlowLayout是流布局，这种布局将其中的组件按照加入的先后顺序从左向右排列， 一行排满之后就转到下一行继续从左至右排列
- GridLayout是网格布局，它以矩形网格形式对容器的组件进行布置。容器被分成大 小相等的矩形，一个矩形中放置一个组件
- 组件的分类：
28.抽象类
| 注意 |
|---|
| (1)抽象类不能被实例化，实例化的工作应该交由它的子类来完成，它只需要有一个引用即可。 |
| (2)抽象方法必须由子类来进行重写。 |
| (3)只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。 |
| (4)抽象类中可以包含具体的方法，当然也可以不包含抽象方法。 |
| (5)子类中的抽象方法不能与父类的抽象方法同名。 |
| (6)abstract不能与final并列修饰同一个类。 |
| (7)abstract 不能与private、static、final或native并列修饰同一个方法。 |
* 实例
//文件名：Animal.java
package selectrubric;
public abstract class Animal {
public abstract void cry();
}//文件名：Cat.java
package selectrubric;
public class Cat extends Animal{
@Override
public void cry(){
System.out.println("猫：喵喵·······");
}
}//文件名：Dog.java
package selectrubric;
public class Dog extends Animal{
@Override
public void cry(){
System.out.println("狗：汪汪·······");
}
}package selectrubric;
//文件名：Continue.java
public class Continue{
public static void main(String[] args) {
Animal a1 = new Cat();
Animal a2 = new Dog();
a1.cry();
a2.cry();
}
}