Java學習總結（四）——面向對象（下）（接口，抽象類，內部類，String類等）

時間 2020-07-29

標籤 java 學習總結面向對象接口抽象部類 string 欄目 Java 简体版

原文原文鏈接

一：Object類java

Object類時Java全部類的根基類（「又稱爲‘祖類’」）程序員
若在Java中未用extends關鍵字指明基類，則編譯器默認爲其基類是object類。正則表達式
例：public class Person{}數組
其意義至關於public class Person extends Object{} 緩存
toString方法：安全
（1）Object類中定義有public String toString()方法，其返回值是String類型，描述當前對象的有關信息。微信
注意：若是直接打印某對象的引用，則默認會調用這個對象的toString()方法，默認打印的內容中包含這個引用所指向的內存地址。app
例：less
StringDemo類：ide
package tostring;
public class StringDemo {
private String name;
private String sex;
private int age;
public StringDemo() {
super();
}
public StringDemo(String name, String sex, int age) {
super();
this.name = name;
this.sex = sex;
this.age = age;
}
public void say(){
System.out.println("我叫"+name+"性別"+sex+"年齡"+age);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
TsetString測試類：
package tostring;
public class TestString {
public static void main(String[] args) {
StringDemo str=new StringDemo();
System.out.println(str);
}
}
結果爲：tostring.StringDemo@15db9742
可見打印的是str的地址
（2）能夠根據須要（例要打引用所指向的內容）在用戶自定義類中重寫toString()方法。
例：
toString類：
package tostring;
public class StringDemo {
private String name;
private String sex;
private int age;
public StringDemo() {
super();
}
public StringDemo(String name, String sex, int age) {
super();
this.name = name;
this.sex = sex;
this.age = age;
}

public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return "name:"+name+" age:"+age+" sex:"+sex;
}
}
TestString測試類：
package tostring;
public class TestString {
public static void main(String[] args) {
StringDemo str=new StringDemo("王剛","男",17);
System.out.println(str);
}
}
結果爲：name:王剛 age:17 sex:男
可見打印結果爲：str地址中所指向的內容
equals()方法:
(1)Object類中定義有public boolean equals(Object obj) 方法，提供定義對象是否「相等」的邏輯。
（2）Object的equals方法定義爲：x.equals(y)，當x和y指向同一個地址時返回true，不然返回false。
（3）String類中已經重寫了equals(Object obj)方法，重寫後的方法比較的是兩個字符串的」內容」是否同樣(注意：==比較對象的引用)
（4）能夠根據須要在用戶自定義類型中重寫equals方法。
例1：
Cat類：
package equalsdemo;

public class Cat {
String color;
int height,wight;

public Cat() {
super();
}

public Cat(String color, int height, int wight) {
super();
this.color = color;
this.height = height;
this.wight = wight;
}

}
TestCat類：
package equalsdemo;

public class TestCat {

public static void main(String[] args) {
Cat cat1=new Cat("白色",1,1);
Cat cat2=new Cat("白色",1,1);
int x,y=1;
x=1;
System.out.println(x==y);
System.out.println("cat1與cat2相等嗎？"+cat1.equals(cat2));
System.out.println("cat1==cat2的結果是："+(cat1==cat2));
}

}
結果爲：x與y相比：true
cat1與cat2相等嗎？false
cat1==cat2的結果是：false
由結果可知：由於cat1和cat2都是新new出來的而且沒有重寫equals方法，因爲他們堆內存中佔據的空間不一樣，因此他們不會相等，cat1和cat2都是堆內存中兩隻貓的引用對象裏邊裝着能夠找到只貓的地址，但因爲兩隻貓的內容存儲在不一樣空間內，因此cat1和cat2裝着的地址永遠不會相同，因此c1==c2也不會相等
例2：（重寫equals方法和字符串比較）
Dog類：
package equalsdemo;

public class Dog {
int color;
int height;
public Dog() {
super();
}
public Dog(int color, int height) {
super();
this.color = color;
this.height = height;
}
@Override
public boolean equals(Object obj) {
if(obj==null){
return false;
}else if(obj instanceof Dog){
Dog dog=(Dog)obj;
if(dog.color==this.color && dog.height==this.height){
return true;
}
}
return false;
}

}
TestDog類：
package equalsdemo;

public class TestDog {

public static void main(String[] args) {
String str1=new String("Hello");
String str2=new String("Hello");
Dog dog1=new Dog();
Dog dog2=new Dog();
System.out.println("字符串相比較：");
System.out.println("str1與str2同樣嗎？"+str1.equals(str2));
System.out.println("用==的結果是："+(str1==str2));
System.out.println("_______________________-");
System.out.println("重寫equals方法得：");
System.out.println("dog1和dog2是一條狗嗎？"+dog1.equals(dog2));
System.out.println("用==的結果是："+(dog1==dog2));
}

}
打印結果：字符串相比較：
str1與str2是同樣嗎？true
用==的結果是：false
_______________________-
重寫equals方法得：
dog1和dog2是一條狗嗎？true
用==的結果是：false
由結果可得：當equals方法重寫後，dog1==dog2輸出爲false，由於比較的是兩個引用中的內容，這兩個引用中的內容固然不相等，並且永遠不會相等，所一輸出爲false；但dog1.equals(dog2)輸出結果爲true，由於咱們在Dog類中重寫了equals方法，改變了這個方法的默認實現，改爲了只要這兩個對象只要真實存在，而且他們的顏色（color）和身高（height）同樣，那麼這兩隻狗咱們就認爲他們徹底相等；比較字符串：str1==str2結果爲false，由於這裏比較的是兩個對象的引用，故他們必定不會相等，但str1.equals(str2)結果爲true，由於String中重寫了從Object類所繼承的equals方法，改變了這個方法的默認實現。
*總結：equals方法重寫時設計規則：
(1)自反性：對任意引用值X,x.equals(x)的返回值必定是true；
（2）對稱性：對於任何引用值x,y當且僅當y.equals(x)時返回值是true時x.equals(y)返回值必定是true；
（3）傳遞性：若是x.equals(y)=true，y.equals(z)=true,則x.equals(z)=true;
(4)一致性：若是參與比較的對象沒有任何改變，則對象的比較結果也不該該有任何改變；
（5）非空性：任何對象的引用值X, x.equals(null)的返回值必定是false
多態性
意義：是由封裝性和繼承性引出的面向對象程序設計語言的另外一特徵。（封裝是爲了保護屬性的一種操做，繼承是爲了擴展類的功能）
多態的體現：
*從方法角度：方法的重載與重寫；
（1）方法重寫（overloading）：子類根據須要重寫父類的方法；
（2）方法重載（override）：傳入的參數不一樣完成的功能也不一樣
*從對象的角度來看：

（1）向上轉型：子類對象轉化爲父類對象，子類對象->父類對象 (程序會自動完成)

格式：父類父類對象=子類實例

注意：向上轉型後，由於操做的是父類對象，因此沒法找到在子類中定義的新方法;但若是子類重寫了父類的某個方法，則調用的是重寫後的方法。

例1：

Person類：

package MethodDuotai;

public class Person {

String name;

int age;

String sex;

public Person() {

super();

}

public Person(String name, int age){

super();

this.name = name;

this.age = age;

}

public Person(String name, int age, String sex) {

super();

this.name = name;

this.age = age;

this.sex = sex;

}

public void say(){

System.out.println("我叫"+name+"年齡"+age+"性別"+sex);

}

Student類：

package MethodDuotai;

public class Student extends Person{

private double score;

public Student() {

super();

}

public Student(String name, int age, String sex,double score) {

super(name,age,sex);

this.score = score;

}

public double getScore() {

return score;

}

public void setScore(double score) {

this.score = score;

}

public void say(){

System.out.println("我叫"+name+"年齡"+age+"性別"+sex+"分數"+score);

}

TestPerson類：

package MethodDuotai;

public class Testperson {

public static void main(String[] args) {

Person per=new Person("張三",12,"男");

Student stu=new Student("張三",12,"男",95.7);

per.say();

stu.say();

}

結果爲：我叫張三年齡12性別男

我叫張三年齡12性別男分數95.7

*紅色標記爲方法的重載；藍色標記爲方法的重寫

向下轉型：父類對象->子類對象 (必須明確的指明要轉型的子類類型)

格式：子類子類對象=(子類)父類實例

注意：向下轉型前必須向上轉型

例2（在例1的基礎上）：

package MethodDuotai;

public class Testperson {

public static void main(String[] args) {

Person per=new Person("張三",12,"男");

Student stu=new Student("張三",12,"男",95.7);

per.say();

stu.say();

System.out.println();

System.out.println("__向上轉型_____");

per=new Student("張三",12,"男",95.7);

//per.walk(); //報錯

per.say();

System.out.println("__向下轉型______");

stu=(Student)per;

per.say();

}

結果爲：

我叫張三年齡12性別男

我叫張三年齡12性別男分數95.7

__向上轉型_____

我叫張三年齡12性別男分數95.7

__向下轉型______

我叫張三年齡12性別男分數95.7

*（1）因而可知向上轉型後父類被重寫後的方法

*（2）向上轉型後沒法訪問子類的新方法

instanceof關鍵字
在Java中利用instanceof關鍵字判斷一個對象是否屬於一個類的實例；

格式：對象 instanceof 類 à返回boolean類型

例：

Animal動物類：

package instanceofdemo;

public class Animal {

private String name;

private int age;

public Animal() {

}

public Animal(String name, int age) {

super();

this.name = name;

this.age = age;

}

public void say() {

System.out.println("我是父類方法say()，姓名：" + this.name + ";年齡：" + this.age);

}

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;

}

Dog狗類：

package instanceofdemo;

public class Dog extends Animal{

public Dog() {

}

public Dog(String name, int age) {

super(name, age);

}

public void plant() {

System.out.println("小狗啃骨頭");

}

Cat貓類：

package instanceofdemo;

public class Cat extends Animal {

private String color;

public Cat() {

}

public Cat(String name, int age, String score) {

super(name, age);

this.color = color;

}

public void learn() {

System.out.println("小貓吃魚~");

}

public String getScore() {

return color;

}

public void setScore(String color) {

this.color = color;

}

InstanceofDemo測試類：

package instanceofdemo;

public class InstanceofDemo {

public static void main(String[] args) {

Dog dog=new Dog();

Cat cat=new Cat();

method(null);

method(dog);

method(cat);

System.out.println("********************");

Animal an=new Dog();

System.out.println(an instanceof Animal); // 判斷是不是Animal類型

System.out.println(an instanceof Dog); // 判斷是不是由Dog類的對象轉換而來

}

public static void method(Animal an){

if(an==null){

System.out.println("不能直接傳遞null!");

return;

}

if(an instanceof Dog){

Dog dog=(Dog)an;

dog.plant();

}

if(an instanceof Cat){

Cat cat=(Cat)an;

cat.learn();

}

結果爲：

不能直接傳遞null!

小狗啃骨頭

小貓吃魚~

********************

true

紅色即爲instanceof關鍵字的用法

final關鍵字

*在Java中聲明類，屬性，方法是可使用final關鍵字來修飾

注意：（1）final修飾變量，則此變量（成員變量或局部變量）成爲常量，只能賦值一次，修飾成員變量時必須賦初值

格式：final 類型變量名（variableName）；

例：public class finaldemo {

final int age=15;

} //修飾成員變量必須賦初值

final修飾類賦，則此類不能被繼承；
final修飾的方法，子類不能重寫；

三．抽象類與接口

1.抽象類：用abstract修飾的類即爲抽象類

（1）格式：abstract class 抽象類名｛

｝

（2）抽象類不能被實例化，必須被繼承，抽象方法必須被重寫，生成它的子類

2．抽象方法：用abstract修飾方法即爲抽象方法，抽象方法沒有方法體；

注意：

（1）抽象類中不必定有抽象方法，但有抽象方法的必定是抽象類

（2）若是子類沒有實現抽象類中的全部抽象方法，則該子類也成爲一個抽象類；

（3）構造方法，靜態方法，私有方法不能被定義爲抽象方法

例：

AbstractPerson抽象類：

package abstractdemo;

public abstract class Person {

String name;

String sex;

public Person() {

super();

}

public Person(String name, String sex) {

super();

this.name = name;

this.sex = sex;

}

public abstract void eat();

}

Student實現類：

package abstractdemo;

public class Student extends Person{

private int age;

public Student() {

super();

}

public Student(String name,String sex,int age) {

super(name,sex);

this.age = age;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public void eat() {

System.out.println("姓名爲"+name+"性別椒"+sex+"年齡爲"+age+"的學生正在吃東西");

}

TestPerson測試類：

package abstractdemo;

public class TestPerson {

public static void main(String[] args) {

Student stu=new Student("佔三","男",18);

stu.eat();

}

結果爲：姓名爲佔三性別椒男年齡爲18的學生正在吃東西

例（爲實現父類中的抽象方法）：

package abstractdemo;

public abstract class Programmer extends Person{

public void coding(){

System.out.println("程序員寫程序");

}

｝

能夠看出仍是抽象類

3.接口（interface）（重點）

（1）接口是抽象方法和常量值定義發的集合

(2) 接口是一種「標準」、「契約」。

(3)從本質上講，接口是一種特殊的抽象類，這種抽象類中只能包含常量和方法的定義，而沒有變量和方法的實現

(4)接口的聲明語法：

·包括接口聲明和接口體

（5）完整的接口聲明:

[public] interface 接口名稱[extends listOfSuperInterface] { … }

#接口體包括常量定義和方法定義

#常量定義: type NAME=value; 該常量被實現該接口的多個類共享; 具備public ,final, static的屬性.

注意：常量名必須大寫

#方法體定義:具備 public和abstract屬性

（6）接口的實現類：

與抽象類同樣，接口要使用也必須經過子類，子類經過implements關鍵字實現接口
一個類能夠實現多個接口,在implements子句中用逗號分開
非抽象子類必須實現接口中定義的全部方法
實現格式：
class 子類 implements接口A，接口B…{
}
(7)接口的使用規則：
接口中全部的方法都是public abstract。
在接口中聲明方法時，不能使用static，final，synchronized，private，protected等修飾符。
一個接口能夠繼承自另外一個接口。
java中不容許類的多繼承，但容許接口的多繼承。
接口中能夠有數據成員，這些成員默認都是public static final
（8）接口的用法：
# 經過接口實現不相關類的相同行爲,而無需考慮這些類之間的關係.
# 經過接口指明多個類須要實現的方法
# 經過接口瞭解對象的交互界面,而無需瞭解對象所對應的類
例：
Animal動物接口：
package interfacedemo;

public interface Animal {
int ID=1;
void breath();
void shout();
}
Run接口：
package interfacedemo;

public interface Run {
void run();

}
Dog實現類：
package interfacedemo;

public class Dog implements Animal{

public void breath() {
System.out.println("小狗在呼吸");
}

public void shout() {
System.out.println("小狗在叫：汪汪");
}

}
Cat實現類：
package interfacedemo;

public class Cat implements Animal,Run{
private String name;

public Cat() {
super();
}

public Cat(String name) {
super();
this.name = name;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public void breath() {
System.out.println("名爲："+name+"的貓在呼吸");
}

public void shout() {
System.out.println("貓在叫：喵喵");

}
public void run() {
System.out.println("小貓在跑");

}

}
TestAnimal測試類：
package interfacedemo;

public class TestAnimal {

public static void main(String[] args) {
Dog dog=new Dog();
Cat cat=new Cat("Tom");
dog.breath();
dog.shout();
System.out.println("*************");
cat.breath();
cat.run();
cat.shout();
}

}
接口Fly繼承接口：
package interfacedemo;

public interface Fly extends Animal,Run {

}

結果爲：小狗在呼吸
小狗在叫：汪汪
*************
名爲：Tom的貓在呼吸
小貓在跑
貓在叫：喵喵
*紅色標記爲接口
*例中實現了接口的用法
*例中綠色標記能夠看出接口能夠實現多繼承

四．基本數據類型的包裝類
1. Java語言針對全部的基本數據類型都提供了對應的包裝類。

基基本數據類型	包裝類
byte（字節）	java.lang.Byte
char（字符）	java.lang.Character
short（短整型）	java.lang.Short
int（整型）	java.lang.Integer
long（長整型）	java.lang.Long
float（浮點型）	java.lang.Float
double（雙精度）	java.lang.Double
boolean（布爾）	java.lang.Boolean

2.（1）基本數據類型轉換爲包裝類

eg：Integer intValue = new Integer(21);

（2）包裝類轉換成基本類型

eg:Integer integerId=new Integer(25);

int intId=integerId.intValue();

3. JDK5.0中爲基本數據類型提供了自動裝箱(boxing)、拆箱(unboxing)功能：

（1）裝箱：將基本數據類型包裝爲對應的包裝類對象

（2）拆箱：將包裝類對象轉換成對應的基本數據類型

Eg: Integer intObject = 5;

int intValue = intObject;

包裝類並非用來取代基本數據類型的

例1：

CharacterDemo類：

package boxing;

public class CharacterDemo {

public static void main(String[] args) {

Character c='a'; // 自動裝箱

char x=c; // 自動拆箱

System.out.println("變爲大寫："+Character.toUpperCase('b'));

System.out.println("變爲小寫："+Character.toLowerCase('Z'));

}

結果爲：變爲大寫：B

變爲小寫：z

例中紅色標記爲自動拆箱與裝箱，綠色標記爲Character類中基本方法的應用

例2：

package boxing;

public class IntegerDemo {

public static void main(String[] args) {

System.out.println("int的最大值："+Integer.MAX_VALUE);

System.out.println("int的最小值："+Integer.MIN_VALUE);

Integer a=100; // 自動裝箱

int b=a; // 自動拆箱

String str="456";

int temp=Integer.parseInt(str); // 將字符串轉換爲int

System.out.println(temp+7);

}

結果爲：int的最大值：2147483647

int的最小值：-2147483648

128

例中紅色標記爲自動拆箱與裝箱，綠色標記爲Integer類中方法的應用

*字符串轉化爲int型特別注意：

例：String str=「123」；

System.out.println(str+5);

結果爲：1235

*若想將str轉化爲int型：

int temp=Integer.parstInt(str);

System.out.println(str+5);

結果爲：128

字符串相關類
1. String類
    (1) String表明字符串類型，字符串的內容自己不可改變，字符串存儲於「字符串常量池」中。
    (2)String的兩種實例化方式
         a:直接賦值法：
         eg: String str=「Hello World」;
**直接賦值法String 內存圖

       b:經過new操做符實例化：
         eg: String str=new String(「Hello World」);
下面是經過new操做符實例化String的內存圖

    (3)一個字符串就是一個String類的匿名對象。
         所謂匿名對象，就是在堆內存中開闢了空間，但在棧內存中並無引用指向的對象。
    (4)字符串經常使用方法
1.public String(byte[] bytes)
  使用平臺的默認字符集解碼，將字節數組轉換爲字符串

2.public String(byte[] bytes,Charset charset)
  使用指定字符集解碼，將字節數組轉換爲字符串

3.public char charAt(int index)
  根據索引位置獲取字符串中的某個字符

4.public boolean contains(CharSequence s)
  判斷當前對象表明的字符串是否包含參數字符串內容

5.public boolean equals(Object anObject)
  判斷字符串內容是否相同

6.public byte[] getBytes()
  將字符串轉換爲字節數組

7.public int indexOf(String str)
  返回參數字符串在當前字符串中的索引位置

9.public int lastIndexOf(String str)
  從後往前找參數字符串，返回參數字符串在當前字符串中的索引位置

10.public int length()
   返回當前字符串的長度

11.public String toLowerCase()
   將字符串轉換爲小寫

12.public String toUpperCase()
   將字符串轉換爲大寫

13.public char[] toCharArray()
   將字符串轉換爲字符數組

14.public String substring(int beginIndex)
   從beginIndex索引位置開始，到字符串末尾，截取字符串

15.public String substring(int beginIndex,int endIndex)
   從beginIndex索引位置開始，到endIndex-1，截取字符串

16.public String trim()
   返回一個字符串,這個字符串刪除了前導和尾隨空格

17.public String[] split(String regex)
   經過指定的正則表達式拆分字符串，將拆分後的結果做爲一個字符串數組返回
例1：
package stringdemo;

public class StringMethod {

public static void main(String[] args) {
String str="我是中國人中華";
System.out.println("字符串中索引位置2的字符是："+str.charAt(2));
System.out.println("字符串中「中」字的索引爲："+str.indexOf("中"));
System.out.println("字符串中倒敘找「中」的索引爲： "+str.lastIndexOf("中"));
System.out.println("字符串的長度是："+str.length());
System.out.println("根據索引位置截取的字符串是："+str.substring(4));
System.out.println("字符串中是否包含「中國人」："+str.contains("中國人"));
System.out.println("由索引截取字符串，起止："+str.substring(2, 5));
String str1="×××";
String str2="我是中國人中華";
System.out.println("字符串str中的內容是否與str1中的相同："+str.equals(str1));
System.out.println("字符串str中的內容是否與str2中的相同："+str.equals(str2));
String str3="abHvhFHn";
System.out.println("將字符串中的大寫轉換爲小寫："+str3.toLowerCase());
System.out.println("將字符串中的小寫轉化爲大寫："+str3.toUpperCase());
String str4="aufafvvidsgd";
char[] a=str4.toCharArray();
System.out.println("將字符串轉化爲字符串數組爲：");
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
System.out.println();
String str5="    zhogn   ";
System.out.println("去除字符串前面和後面的空格爲："+str5.trim());
String str6="12345668";
byte[] b=str6.getBytes();
System.out.println("將字符串轉換爲字節數組爲："+b);
String s=new String(b);
System.out.println("將字節數組轉換爲字符串爲："+s);
String score="56,67,78,56,32,98.76";
String[] sco=score.split(",");
System.out.println("按照既定的規則拆分字符串：");
for( String x:sco){
System.out.print(x+" ");
}
}

}
結果爲：
字符串中索引位置2的字符是：中
字符串中「中」字的索引爲：2
字符串中倒敘找「中」的索引爲： 5
字符串的長度是：7
根據索引位置截取的字符串是：人中華
字符串中是否包含「中國人」：true
由索引截取字符串，起止：中國人
字符串str中的內容是否與str1中的相同：false
字符串str中的內容是否與str2中的相同：true
將字符串中的大寫轉換爲小寫：abhvhfhn
將字符串中的小寫轉化爲大寫：ABHVHFHN
將字符串轉化爲字符串數組爲：
a u f a f v v i d s g d
去除字符串前面和後面的空格爲：zhogn
將字符串轉換爲字節數組爲：[B@15db9742
將字節數組轉換爲字符串爲：12345668
按照既定的規則拆分字符串：
56 67 78 56 32 98.76
例 2：
package stringdemo;

public class String02 {

public static void main(String[] args) {
String str1="Hello";
String str2="Hello";
System.out.println(str1==str2);
System.out.println(str1.equals(str2));
String str3=new String("Hello");
System.out.println(str1.equals(str3));
}

}
結果爲：true
true
True
具體緣由equals中已經解釋
String方法應用練習：
1.編寫程序，統計出字符串「want you to know one thing」
   中字母n和字母o的出現次數

2.分別截取字符串"   ABCmnyCW123   "中的"CmnyCW123"部分和"CW123"部分。
  提示：會使用到indexOf(xx) lastIndexOf(xxx) substring(xxx) trim()方法。
解析1：
package stringdemo;

public class StringArrray {

public static void main(String[] args) {
String str="want you to know one things";
char[] c=str.toCharArray();
int n=0;
int o=0;
for(int i=0;i<c.length;i++){
if(c[i]=='n'){
n++;
}
if(c[i]=='o'){
o++;
}
}
System.out.println("出現n的次數："+n);
System.out.println("出現o的次數："+o);
}

}
結果爲：出現n的次數：4
出現o的次數：4
解析2：
package stringdemo;

public class Substring {

public static void main(String[] args) {
String str=" ABCmnyCW123 ";
int s=str.indexOf("C");
System.out.println("截取後的結果是："+str.substring(s).trim());
int c=str.lastIndexOf("C");
System.out.println("第二次截取後的結果是："+str.substring(c).trim());
}

}
結果爲：截取後的結果是：CmnyCW123
第二次截取後的結果是：CW123

StringBuffer類
StringBuffer表明可變的字符序列（StringBuffer稱爲字符緩衝區），其工做原理爲:預先申請一塊內存，存放字符序列，若是字符序列滿了會從新擴展緩存區的大小，以容納更多的字符序列。
StringBuffer是可變換對象，這是與String最大的不一樣。(若是連續操做String對象，則會產生大量的「垃圾」，並且「斷開-鏈接」很頻繁。
例（String應用）：
package stringbuffer;

public class StringBufferMethod {

public static void main(String[] args) {
StringBuffer sb=new StringBuffer();
sb.append("中國").append("香水").append("Java");
System.out.println("反轉以前：");
System.out.println(sb.toString());
sb.reverse();   // 反轉緩衝區的內容
System.out.println("反轉以後：");
System.out.println(sb.toString());

StringBuffer sb2=new StringBuffer();
sb2.append(false).append(12.5).append("hello");
sb2.insert(1,true);   // 在索引爲1處插入true
System.out.println(sb2);

}

}
運行結果爲：
反轉以前：
中國香水Java
反轉以後：
avaJ水香國中
ftruealse12.5hello

例2；
package stringbuffer;

public class StringBufferDemo {

public static void main(String[] args) {
StringBuffer sb=new StringBuffer();
sb.append("hello");
long start=System.currentTimeMillis();
for(int i=0;i<10000;i++){
sb.append(i);
}
long end=System.currentTimeMillis();
        System.out.println("使用StringBuffer耗時："+(end-start));
        System.out.println(sb.length());

    }

}
運行結果爲：使用StringBuffer耗時：6
38895
3.StringBuilder類
   StringBuilder和StringBuffer功能幾乎是同樣的，只是 StringBuilder是線程不安全的
內部類
1.在類的內部定義另外一個類。若是在類Outer的內部再定義一個類Inner，此時Inner就稱爲內部類，而Outer則稱爲外部類。
2.內部類的定義格式：
Public class 外部類{
外部類成員
Public class 內部類{
內部類成員
}
}
內部類在編譯完成後也會產生.class文件，而文件名稱則是」外部類名稱$內部類名稱.class」
使用內部類的緣由：心臟屬於人類的某個部分：但心臟不能簡單用屬性或者方法表示一個心臟，由於心臟也有本身的屬性和行爲，因此須要寫在人類的內部
使用內部類的緣由：（1）好處：能夠方便地訪問外部類的私有屬性；減小了類文件編譯後的產生的字節碼文件的大小。（2）缺點:使程序結構不清楚
內部類分類（重點）：
成員內部類
*成員內部類中不能定義static變量
*成員內部類持有外部類的引用
*在文件管理方面，成員內部類在編譯完成後也會產生.class文件，而文件名稱則是」外部類名稱$內部類名稱.class」
*外部實例化成員內部類的格式：
外部類.內部類內部類對象=外部類實例.new 內部類()
例1（成員內部類）：
成員內部類：
package memberclass;

public class Outer {
private int num=5;

public void test(){
Inner inner=new Inner();
inner.show();
}
class Inner{
public void show(){
System.out.println("num="+num);
}
}
}
測試成員內部類：
package memberclass;

public class TestMemclass {

public static void main(String[] args) {
Outer outer=new Outer();
outer.test();

}
}
結果：num=5
例2：
package memberclass;

public class Outer02 {
private String name="張三";

class Inner{
public void say(){
System.out.println("我叫"+name);
}
}
public Inner getInner(){
return new Inner();
}
}
TestInner類：
package memberclass;

public class TestInner {

public static void main(String[] args) {
// 經過在外部類中的成員方法中獲取內部類對象
Outer02 outer=new Outer02();
outer.getInner().say();
// 外部類.內部類內部類對象=外部類實例.new 內部類();
Outer02.Inner inner=outer.new Inner();
inner.say();
}
}
結果爲：我叫張三
我叫張三
例中詳細的作出了訪問成員內部類的方法
靜態內部類：
*若是一個內部類使用static聲明，則此內部類就稱爲靜態內部類，其實也至關於外部類。能夠經過外部類.內部類來訪問。
*靜態內部類不會持有外部類的引用，建立時能夠不用建立外部類對象
*靜態內部類能夠訪問外部的靜態變量，若是訪問外部類的非static成員變量必須經過外部類的實例訪問
*外部實例化靜態內部類對象的格式：
外部類.內部類內部類對象= new 外部類.內部類();
例：
靜態內部類：
package staticclass;

public class Outer {
private String name="張三丰";
private static int age=22;

static class Inner{
public void say(){
System.out.println("訪問外部了靜態變量：age="+age);
Outer outer=new Outer();
System.out.println("訪問外部類非靜態變量："+outer.name);
}
}

}
測試靜態內部類：
package staticclass;

public class TestInner {

public static void main(String[] args) {
Outer.Inner inner=new Outer.Inner();
inner.say();
}

}
結果：訪問外部了靜態變量：age=22
訪問外部類非靜態變量：張三丰
局域內部類：
*局域內部類是定義在一個方法中的內嵌類，因此類的做用範圍僅限於該方法中，而類生成的對象也只能在該方法中使用。
* 局域內部類不能包含靜態成員
* 特別注意：局域內部類要想訪問包含其的方法中的參數，則方法中的參數前必須加上final關鍵字(JDK<=1.7)。
例：
局域內部類：
package localclass;

public class Outer {
private int age=23;
private String name="希特勒";
public void say(int x){
class Inner{
public void talk(){
System.out.println("直接訪問外部類變量此人age:"+age+"name:"+name);
System.out.println("訪問外部類方法傳參："+x);
}
}
Inner inner=new Inner();
inner.talk();
}

}
測試局域內部類：
package localclass;

public class TestLocal {

public static void main(String[] args) {
Outer outer=new Outer();
outer.say(27);
}

}
結果：直接訪問外部類變量此人age:23name:希特勒
訪問外部類方法傳參：27
匿名內部類：
*若是一個內部類在整個操做中只使用一次的話，就能夠定義爲匿名內部類
*沒有名字的內部類，這是java爲了方便咱們編寫程序而設計的一個機制，由於有時候有的內部類只須要建立一個它的對象就能夠了，之後再不會用到這個類，這時候使用匿名內部類就比較合適
例：
動物接口：
package anonumityclass;

public interface Animal {
void shout();

}
測試匿名內部類：
package anonumityclass;

public class TestAnonumity {

public static void main(String[] args) {
//定義匿名內部類做爲參數傳遞給animalShout()方法
animalShout(new Animal(){
//實現shout方法
public void shout(){
System.out.println("喵喵~~~~~");
}
});
}
//定義靜態方法animalShout
public static void animalShout(Animal an){
an.shout();//調用傳入對象an的shout（）方法
}

}
小結（以一個做業題結束）：
(1)定義如下這些接口和類,並完成相關屬性和方法的聲明和調用.數據類型,參數列表,返回值類型等請根據題目須要自行定義.
學習接口Learning(包含方法: 預習preLearn,上課lessons,複習reveiw)
喝酒接口Drinking(包含方法: 喝酒drink, 吐throwup,耍酒瘋playMad)
抽象類Person(包含屬性:姓名,性別,年齡; 抽象方法:談戀愛love)
學生Student是人,得會學習,但不能喝酒(由於會使大腦變笨);他們還有本身的學校(school),還喜歡和朋友聊微信(chatting).
公務員Officer是人,不用學習,但常常須要喝酒應酬;他們還得常常開一些無聊的會議(meeting).
程序猿Programmer,是人,必須常常學習,較少社交因此不喝酒;他們特別喜歡寫代碼(coding),和修bug(debuging).

(2)在場景類Client中定義一個方法method1,在形參和實參上體現對象的多態性,在方法中進行調用,若是對象的實際類型是學生,
   就和朋友聊微信;若是是公務員,就去開會;若是是程序猿,就去寫代碼和修bug.

(3)直接打印一個學生對象,就能如下面格式來輸出:
學生信息: 姓名:張三,性別:男,年齡:20,學校:北大.

(4)若是兩個學生的姓名、性別、年齡、學校同樣，則認爲這兩個學生「相等」。

學習接口：
package studyDemo;

public interface Learning {
void preLearn();
void lessons();
void reveiw();

}
喝酒接口:
package studyDemo;

public interface Drinking {
void drink();
void throwup();
void palyMad();
}

Person抽象類：

package studyDemo;

public abstract class Person{
String name;
int age;
String sex;

public Person() {
super();
}

public Person(String name, int age, String sex) {
super();
this.name= name;
this.age = age;
this.sex = sex;
}

public abstract void love();

}
學生Student實現類：
package studyDemo;

public class Student extends Person implements Learning{
private String shoolName;

public Student() {
super();
}

public Student(String shoolName,String name,int age,String sex) {
super(name,age,sex);
this.shoolName = shoolName;
}

public void preLearn() {
System.out.println(name+"同窗正在預習中~~");
}

public void lessons() {
System.out.println("上課了"+name+"同窗上課去了");
}

public void reveiw() {
System.out.println("上課完畢，回家複習~~");
}

public void chating(){
System.out.println(shoolName+"的學生"+name+"和朋友聊微信中~~");
}

public String getShoolName() {
return shoolName;
}

public void setShoolName(String shoolName) {
this.shoolName = shoolName;
}

public void love() {
// TODO Auto-generated method stub
System.out.println(name+"是位"+sex+"生今年"+age+"歲了，在和對面男生談戀愛~~");
}
@Override
public boolean equals(Object obj) {
if(this==obj){
System.out.println("$學生本身比本身，固然是同一人！");
return true;
}
if(obj==null){
System.out.println("$傳入參數爲null,沒法比較！");
return false;
}
if(!(obj instanceof Student)){
System.out.println("$傳遞的不是學生對象！");
return false;
}
Student stu=(Student)obj;
if(this.name!=null && this.name.equals(stu.name) && this.age==stu.age && this.sex==stu.sex){
return true;
}
return false;
}
public String toString() {
// TODO Auto-generated method stub
return "學生    [姓名：" + name + ", 年齡：" + age + ", 性別：" + sex
+ "]";
}
}

程序員實現類：

package studyDemo;

public class Programmer extends Person implements Learning{

public Programmer(){

}

public Programmer(String name,int age,String sex){
super(name,age,sex);
}
public void preLearn() {
// TODO Auto-generated method stub
System.out.println("名爲"+name+"的程序員正在預習~");
}

public void lessons() {
// TODO Auto-generated method stub
System.out.println(name+"正在上課中~");
}

public void reveiw() {
// TODO Auto-generated method stub
System.out.println("上課完畢，回家複習~");
}

public void love() {
// TODO Auto-generated method stub
System.out.println(name+"是位"+sex+"程序員，今年"+age+"歲正在和隔壁女孩談戀愛~");
}

public void coding(){
System.out.println(name+"程序員特別喜歡寫代碼~");
}

public void debuging(){
System.out.println(name+"也喜歡修電腦Bug");
}

public String toString() {
// TODO Auto-generated method stub
return "程序員    [姓名：" + name + ", 年齡：" + age + ", 性別：" + sex
+ "]";
}
}

公務員實現類：

package studyDemo;

public class Officer extends Person implements Drinking{

public Officer(){
super();
}

public Officer(String name, int age, String sex) {
// TODO Auto-generated constructor stub
super(name,age,sex);
}

public void drink() {
// TODO Auto-generated method stub
System.out.println(name+"正在應酬喝酒~");
}

public void throwup() {
// TODO Auto-generated method stub
System.out.println("他喝多吐了");
}

public void palyMad() {
// TODO Auto-generated method stub
System.out.println("這位"+sex+"公務員，名叫"+name+"喝多了，正在耍酒瘋~");
}

public void love() {
// TODO Auto-generated method stub
System.out.println("這位"+age+"的公務員正在和對面的女孩談戀愛~");
}

public void meeting(){
System.out.println("公務員"+name+"在無聊的開會中~");
}

public String toString() {
// TODO Auto-generated method stub
return "公務員    [姓名：" + name + ", 年齡：" + age + ", 性別：" + sex
+ "]";
}
}

Client情景測試類：
package studyDemo;

public class Client {

public static void main(String[] args) {
System.out.println("學生模塊：");
Student stu=new Student("西部開源","李芳",18,"女");
stu.preLearn();
stu.lessons();
stu.reveiw();
stu.chating();
stu.love();
System.out.println("__toString應用___________-");
System.out.println(stu);
System.out.println("**********************");
System.out.println("公務員模塊：");
Officer cer=new Officer("王磊",35,"男");
cer.drink();
cer.throwup();
cer.palyMad();
cer.meeting();
cer.love();
System.out.println("____toString應用____________-");
System.out.println(cer);
System.out.println("**********************");
System.out.println("程序員模塊：");
Programmer pro=new Programmer("馮超",24,"男");
pro.preLearn();
pro.lessons();
pro.reveiw();
pro.coding();
pro.debuging();
pro.love();
System.out.println("______toString應用____________");
System.out.println(pro);
System.out.println("***********************");
System.out.println("學生比較模塊:");
System.out.println("________equals比較運用___________");
Student stu1=new Student("西部開源","張三", 10,"男");
Student stu2=new Student("西部開源","張三", 10,"男");
Student stu3=new Student("西部開源","李四", 10,"男");
Student stu4=new Student("西安交大","張三", 25,"男");
stu1.equals(null);
stu1.equals(pro);
stu1.equals(stu1);
boolean flag1=stu1.equals(stu2);
if(flag1){
System.out.println("學生1與學生2是同一人");
}else{
System.out.println("學生1與學生2不是同一人");
}
System.out.println(stu1.equals(stu3)?"學生1與學生3是同一人":"學生1與學生3不是同一人");
System.out.println(stu1.equals(stu4)?"學生1與學生4是同一人":"學生1與學生4不是同一人");
System.out.println(stu2.equals(stu3)?"學生2與學生3是同一人":"學生2與學生3不是同一人");
System.out.println(stu2.equals(stu4)?"學生2與學生4是同一人":"學生2與學生4不是同一人");
System.out.println(stu3.equals(stu4)?"學生3與學生4是同一人":"學生3與學生4不是同一人");
System.out.println("************************");
System.out.println("_______instanceof的應用________");
System.out.println("——傳入爲空時——：");
interfaceofDemo(null);
System.out.println();
System.out.println("——傳入爲學生時——：");
interfaceofDemo(stu);
System.out.println();
System.out.println("——傳入爲程序員時——：");
interfaceofDemo(pro);
System.out.println();
System.out.println("——傳入爲公務員時——：");
interfaceofDemo(cer);
System.out.println();
System.out.println("————————————做業完結——————————————————");

}
public static void interfaceofDemo(Person per){
if(per==null ){
System.out.println("傳入爲空：中止");
return;
}
if(per instanceof Student){
Student stu=(Student)per;
stu.lessons();
stu.preLearn();
stu.reveiw();
}
if(per instanceof Programmer){
Programmer pro=(Programmer)per;
pro.coding();
pro.debuging();
}
if(per instanceof Officer){
Officer cer=(Officer)per;
cer.meeting();
}
}

}

運行結果：

學生模塊：
李芳同窗正在預習中~~
上課了李芳同窗上課去了
上課完畢，回家複習~~
西部開源的學生李芳和朋友聊微信中~~
李芳是位女生今年18歲了，在和對面男生談戀愛~~
__toString應用___________-
學生    [姓名：李芳, 年齡：18, 性別：女]
**********************
公務員模塊：
王磊正在應酬喝酒~
他喝多吐了
這位男公務員，名叫王磊喝多了，正在耍酒瘋~
公務員王磊在無聊的開會中~
這位35的公務員正在和對面的女孩談戀愛~
____toString應用____________-
公務員    [姓名：王磊, 年齡：35, 性別：男]
**********************
程序員模塊：
名爲馮超的程序員正在預習~
馮超正在上課中~
上課完畢，回家複習~
馮超程序員特別喜歡寫代碼~
馮超也喜歡修電腦Bug
馮超是位男程序員，今年24歲正在和隔壁女孩談戀愛~
______toString應用____________
程序員    [姓名：馮超, 年齡：24, 性別：男]
***********************
學生比較模塊:
________equals比較運用___________
$傳入參數爲null,沒法比較！
$傳遞的不是學生對象！
$學生本身比本身，固然是同一人！
學生1與學生2是同一人
學生1與學生3不是同一人
學生1與學生4不是同一人
學生2與學生3不是同一人
學生2與學生4不是同一人
學生3與學生4不是同一人
************************
_______instanceof的應用________
——傳入爲空時——：
傳入爲空：中止

——傳入爲學生時——：
上課了李芳同窗上課去了
李芳同窗正在預習中~~
上課完畢，回家複習~~

——傳入爲程序員時——：
馮超程序員特別喜歡寫代碼~
馮超也喜歡修電腦Bug

——傳入爲公務員時——：
公務員王磊在無聊的開會中~

————————————做業完結—————————————————
【總結完畢】
2017.12.26（西開）