Java重点知识详解

江小虫儿

已于 2022-01-30 12:06:43 修改

阅读量762

点赞数 1

分类专栏： Java 文章标签： java 数组的定义和初始化接口 Object类 String类

于 2017-08-22 18:15:42 首次发布

本文链接：https://blog.csdn.net/Kate_sicheng/article/details/77483630

版权

Java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

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<int<long<float<double（注意这是是容量大小不是所占字节数）
容量小的类型自动转换成容量大的数据类型
容量大的数据类型转换成容量小的数据类型时，要加上强制转换符，但是可能造成精度降低，或者溢出。
比喻，当一个小的容器的水换到一个大的容器中毫无问题，但是一个大的容器的水换成小的容器则会装不下，就会溢出。
有多种数据类型混合运算时，系统将自动所有数据转换成最大的那个类型，然后进行运算。
实数常量，系统默认为double；
整数常量，系统默认为int；
所以long lg = 10000000000l;后面要加一个l，不然系统会保存因为默认为int就超出范围了

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 Home

6.判断字符串的开始与结尾
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,XYZ

	String str="5678|XYZ";  
	String[] b = str.split("|");  //注意直接使用|，该字符是正则表达式的一部分，  
	String x="结果: ";  
	for(int i=0;i<b.length;i++){  
	    x=x+b[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, Event

Sports.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。

方法	说明
`clone()`	保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。
`getClass()`	返回Object 的运行时类
`finalize()`	用于释放资源。因为无法确定该方法什么时候被调用，很少使用 finalize()是由JVM自动调用的,JVM感觉内存空间有限时，才会开始执行finalize()
`toString()`	用得比较多，一般子类都有覆盖
`equals()`	非常重要的一个方法。一般equals和==是不一样的，但是在Object中两者是一样的。子类一般都要重写这个方法。
`notify()`	唤醒在该对象上等待的某个线程
`notifyAll()`	唤醒在该对象上等待的所有线程
`hashCode()`	用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。一般必须满足obj1.equals(obj2)==true。可以推出obj1.hash- Code()==obj2.hashCode()，但是hashCode相等不一定就满足equals。不过为了提高效率，应该尽量使上面两个条件接近等价。
`wait()`	使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。调用该方法后当前线程进入睡眠状态，直到以下事件发生： (1) 其他线程调用了该对象的notify方法。 (2) 其他线程调用了该对象的notifyAll方法。 (3) 其他线程调用了interrupt中断该线程。 (4) 时间间隔到了。此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

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;i<buf.length;i++){
			if(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]    数组长度：4

20.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.98

22.进制转换

使用Long类中的方法得到整数之间的各种进制转换的方法：

转化为二进制：Long.toBinaryString(long l)
转化为八进制：Long.toOctalString(long l)
转化为十六进制：Long.toHexString(long l)
p作为任意进制： Long.toString(long l, int 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();  
    }  
}

江小虫儿

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java重点知识详解

详解： this关键字、对象Object、抽象类、作用范围、接口、super关键字、封装、继承、重载、数组、异常、String 和 StringBuffer、运算符优先级、进制转换、重用字符串的方法和对象的方法...
复制链接

扫一扫