JAVA78总结

2017.12.24

面向对象的多态性

1.Object类的toString()与equals(Object obj)方法；

2.面向对象的对态性；

3.抽象类与接口。

一.Object类

（1）Object类是JAVA类的根基类，若在类声明中未使用extends关键字指明其基类，则默认基类为Object类。

（2）toString()方法

    定义：public  String toString()，其返回值是String类型作用是描述当前对象的有关信息。

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

在此，要根据需要在用户自定义类中重写toString()方法。

eg:

//学生类

package object;

public class Student{
private String name;
private int age;
private double score;


public Student() {


}


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


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;
}


@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score
+ "]";
}


}

//toString类

package object;

public class ToStringDemo {
public static void main(String[] args) {
Student stu=new Student("张三",20,83.5);
                System.out.println(stu);
}


}      

（2）equals()方法

  定义：public boolean  equals(Object obj)根据定义对象是否“相等”的逻辑。

 比较：x.equals(y),当x和y指向同一个地址时返回true,否则返回false.

 String类中已经重写了equals(Object obj)方法，重写后的方法比较的是两个字符串的“内容”是否一样

注意：==比较的是对象的引用

同样可以根据需要在用户自定义类型中中重写equals方法。

//接上面学生类

//equals类

package object;

public class EqualsDemo {

public static void main(String[] args) {
Student stu1=new Student("张三",20,83.5);
Student stu2=new Student("张三",20,83.5);
System.out.println("stu1与stu2相等吗？"+stu1.equals(stu2)); //在上面的学生类中未重写equals方法，则这里比较两对象的指                                                                                                                         向地址。                                                                                                   
}
}

二.多态性

  （1）  封装：保护属性；

              继承：扩展类的功能；

             多态性：是由封装性和继承性引出的面向对象程序设计语言的另一特征。

  （2）多态的体现：

   a.从方法的角度：方法的重载和重写

   b.从对象的角度 ：@1向上转型（子类对象转为父类对象）格式：父类 父类对象=子类实例

                                向上转型后，因为操作的是父类对象，所以无法找到在子类中定义的新方法；但 如果子类重写了父类的某个方                                       法，则调用的是重写后的方法。

                                   @2向下转型（父类对象转为子类对象）格式：子类 子类对象=（子类）父类实例

                                   注意 ：向下转型前先要向上转型

eg:

*向上转型

//父类

package duotai.upper;

public class Person {
private String name;
private int age;

public Person() {
}


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


public void say() {
System.out.println("我是父类方法say()，姓名：" + this.name + ";年龄：" + this.age);
}

public void learn(){
System.out.println("父类的learn()方法，人学习...");
}


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;
}


}

//子类

package duotai.upper;

public class Student extends Person {
private double score;


public Student() {
}


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


@Override
public void learn() {
System.out.println("学生学习...");
}


public double getScore() {
return score;
}


public void setScore(double score) {
this.score = score;
}
}

//test类

package duotai.upper;

public class TestUpper {


public static void main(String[] args) {
Student stu=new Student("张三",20,83.5);
Person per=stu;   // 向上转型
per.say();
per.learn();

}

}                            

eg:

*向下转型    

//父类

package duotai.down;

public class Person {
private String name;
private int age;

public Person() {
}


public Person(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;
}


}

//子类

package duotai.down;

public class Person {
private String name;
private int age;

public Person() {
}

public Person(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;
}

}

//test类

package duotai.down;

public class TestDown {

public static void main(String[] args) {
Person per=new Student("张三",20,83.5);   // 向上转型
Student stu=(Student)per;   // 向下转型
                stu.learn();   
}

}

（3）instanceof 关键字

 JAVA中使用它判断一个对象是否属于一个类的实例

 格式：对象  instanceof  类   ，其返回boolean类型

eg:

//农民类

  定义：可变的字符序列，称为字符串缓冲区。其预先申请一块内存，存放字符序列，如果字符序列满了，会重新改变缓存区的大小，以容纳更多的字符序列。

 1、StringBuffer类是可变对象，不会产生大量“垃圾”，而且不需要“断开-连接”。

 eg1://String类

package stringbuffer;

public class StringDemo {

public static void main(String[] args) {
String str="hello";
// 会产生大量的“垃圾”，而且不断“断开-连接”消耗性能
long start=System.currentTimeMillis();
        for(int i=0;i<10000;i++){
        str+=i;   // str=str+i
        }
        long end=System.currentTimeMillis();
        System.out.println("使用String耗时："+(end-start));
        System.out.println(str.length());
}

}

//StringBuffer类

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());
        
     //   sb.append("abc").append(false).append(12.5);
}
}

 eg2:

 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);
}
}

（3）StringBuilder类（线程 不安全）

 StringBuilder和StringBuffer功能几乎是一样的。

三、内部类

 （1）定义：在类的内部定义另一个类

    定义格式：public class 外部类{

             //外部类的成员

             public class 内部类{

             //内部类的成员

             }

           }

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

   使用内部类好处：a.方便访问外部类的私有属性；

              b.减少了类文件编译后产生的字节码文件的大小。

          缺点：使程序结构不清楚

  （2）成员内部类：类中不能定义static变量；成员内部类持有外部类的引用；内部类在编译完成后也会产生.class文件，而文件名称则是”外部类名称$内部类名称.class”

   外部类实例化成员内部类的格式：

    外部类.内部类 内部类对象=外部类实例.new 内部类（）；

eg：

package inner.member;

public class Outer {
   private String name="中国人";
   
   // 成员内部类
   class MemberInner{
  public void method(){
  System.out.println("内部类可以访问外部类的私有属性："+name);
  }
   }
   
   public MemberInner getMemberInstance(){
  return new MemberInner();
   }
}

//test类

package inner.member;

public class TestMember {

public static void main(String[] args) {
Outer out=new Outer();
out.getMemberInstance().method();   // 通过在外部类中的成员方法中获取内部类对象
        
// 外部类.内部类  内部类对象=外部类实例.new 内部类();
Outer.MemberInner in=out.new MemberInner();
in.method();
}
}

（3）静态内部类

  定义：如果一个内部类使用static声明，称此类为静态内部类，其也相当于外部类。可通过外部类.内部类来访   问。

  静态内部类不会持有外部类的引用，创建时可以不用创建外部类对象；

  静态内部类可以访问外部的静态变量，如果访问外部类的非static成员变量必须通过外部类的实例访问

  外部实例化静态内部类对象的格式：

   外部类.内部类  内部类对象= new 外部类.内部类();

 eg:package inner.staticdemo;
public class Outer {
   private String name="中国";
   private static int population=14;
   
   static class StaticInner{
  public void method(){
  System.out.println("静态内部类直接访问外部类的static属性："+population);
  Outer out=new Outer();
  System.out.println("在静态内部类中通过外部类对象访问非static属性："+out.name);
  }
   }
   
   public static StaticInner getStaticInner(){
  return new StaticInner();
   }
}

//test类

package inner.staticdemo;

public class TestStaticInner {

public static void main(String[] args) {
Outer.getStaticInner().method();
System.out.println("************************");
        Outer.StaticInner in=new Outer.StaticInner();
        in.method();
}
}

（4）局域内部类

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

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

特别注意：局域内部类要想访问包含其的方法中的参数，则方法中的参数前必须加上final关键字(JDK<=1.7)。

（5）匿名内部类(没有名字的内部类)

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

eg:package inner.anonymity;

public interface Jumping {
    public void jump();
}

//test类

package inner.anonymity;

public class TestAnonumity {

public static void main(String[] args) {
Jumping j=new Jumping(){

@Override
public void jump() {
System.out.println("某人跳楼了...");
}

};
j.jump();
}


}