一:Object

  1. Object类时Java所有类的根基类(“又称为‘祖类’”)

  2. 若在Java中未用extends关键字指明基类,则 编译器默认为其基类是object类。

     例:public class Person{}

    其意义相当于public class  Person extends Object{}

  3. toString方法:

    1Object类中定义有public  String toString()方法,其返回值是String类型,描述当前对象的有关信息。

    注意:如果直接打印某对象的引用,则默认会调用这个对象的toString()方法,默认打印的内容中包含这个引用所指向的内存地址。

    例:

    StringDemo类:

    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地址中所指向的内容

  4. equals()方法:

    (1)Object类中定义有public boolean equals(Object obj) 方法,提供定义对象是否“相等”的逻辑。

    2Objectequals方法定义为:x.equals(y),当xy指向同一个地址时返回true,否则返回false

    3String类中已经重写了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

    由结果可知:因为cat1cat2都是新new出来的并且没有重写equals方法,由于他们堆内存中占据的空间不同,所以他们不会相等,cat1cat2都是堆内存中两只猫的引用对象里边装着可以找到只猫的地址,但由于两只猫的内容存储在不同空间内,所以cat1cat2装着的地址永远不会相同,所以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)时返回值是truex.equals(y)返回值一定是true

    3)传递性:如果x.equals(y)=truey.equals(z)=true,x.equals(z)=true;

    (4)一致性:如果参与比较的对象没有任何改变,则对象的比较结果也不应该有任何改变;

    5)非空性:任何对象的引用值X, x.equals(null)的返回值一定是false

     

  5. 多态性

    意义:是由封装性和继承性引出的面向对象程序设计语言的另一特征。(封装是为了保护属性的一种操作,继承是为了扩展类的功能)

  6. 多态的体现:

    *从方法角度:方法的重载与重写;

    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

*红色标记为方法的重载;蓝色标记为方法的重写

 

  1. 向下转型:父类对象->子类对象 (必须明确的指明要转型的子类类型)

格式:子类 子类对象=(子类)父类实例

注意:向下转型前必须向上转型

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)向上转型后无法访问子类的新方法

  1. instanceof关键字

  2. 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

true

红色即为instanceof关键字的用法

  1. final关键字

*Java中声明类,属性,方法是可以使用final关键字来修饰

注意:(1final修饰变量,则此变量(成员变量或局部变量)成为常量,只能赋值一次,修饰成员变量时必须赋初值

格式:final 类型 变量名(variableName);

例:public class finaldemo {

final int age=15;

}   //修饰成员变量必须赋初值

  1. final修饰类赋,则此类不能被继承;

  2. 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的属性.

注意:常量名必须大写

#方法体定义:具有 publicabstract属性

6)接口的实现类:

  • 与抽象类一样,接口要使用也必须通过子类,子类通过implements关键字实现接口

  • 一个类可以实现多个接口,implements子句中用逗号分开

  • 非抽象子类必须实现接口中定义的所有方法

  • 实现格式:

    class 子类 implements接口A,接口B…{

    }

    (7)接口的使用规则:

  • 接口中所有的方法都是public abstract

  • 在接口中声明方法时,不能使用staticfinalsynchronizedprivateprotected等修饰符。

  • 一个接口可以继承自另一个接口。

  • 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基本数据类型转换为包装类

 egInteger 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. 字符串相关类

      1. String

          (1) String代表字符串类型,字符串的内容本身不可改变,字符串存储于“字符串常量池”中。

          (2)String的两种实例化方式

               a:直接赋值法:

               eg:  String str=Hello World;

      **直接赋值法String 内存图

       String直接赋值内存图.png

             b:通过new操作符实例化:

               eg: String str=new String(Hello World);

      下面是通过new操作符实例化String的内存图

       通过new实例化String对象.png

          (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

  1. StringBuffer类

  2. StringBuffer代表 可变的字符序列(StringBuffer称为字符缓冲区),其工作原理为:预先申请一块内存,存放字符序列,如果字符序列满了会重新 扩展缓存区的大小,以容纳更多的字符序列。

  3. 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是线程不安全的

  4. 内部类

    1.在类的内部定义另一个类。如果在类Outer的内部再定义一个类Inner,此时Inner就称为内部类,而Outer则称为外部类。

    2.内部类的定义格式:

    Public class 外部类{

    外部类成员

    Public class 内部类{

    内部类成员

    }

    }

  5. 内部类在编译完成后也会产生.class文件,而文件名称则是”外部类名称$内部类名称.class

  6. 使用内部类的原因:心脏属于人类的某个部分:但心脏不能简单用属性或者方法表示一个心脏,因为心脏也有自己的属性和行为,所以需要写在人类的内部

  7. 使用内部类的原因:(1)好处:可以方便地访问外部类的私有属性;减少了类文件编译后的产生的字节码文件的大小。(2)缺点:使程序结构不清楚

  8. 内部类分类(重点):

  9. 成员内部类

    *成员内部类中不能定义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();

    }

    }

    结果为:我叫张三

    我叫张三

    例中详细的做出了访问成员内部类的方法

  10. 静态内部类:

    *如果一个内部类使用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

    访问外部类非静态变量:张三丰

  11. 局域内部类:

    *局域内部类是定义在一个方法中的内嵌类,所以类的作用范围仅限于该方法中,而类生成的对象也只能在该方法中使用。

    * 局域内部类不能包含静态成员

    * 特别注意:局域内部类要想访问包含其的方法中的参数,则方法中的参数前必须加上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

  12. 匿名内部类:

    *如果一个内部类在整个操作中只使用一次的话,就可以定义为匿名内部类

    *没有名字的内部类,这是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(西开)