1、面向对象特征之继承性(inheritance)

为描述和处理个人信息，定义类Person:

class Person {
	public String name;
	public int age;
	public Date birthDate;
	public String getInfo() {
		//...
	}
}

为描述和处理学生信息，定义类Student:

class Student {
	public String name;
	public int age;
	public Date birthDate;
	public String school;
	public String getInfo() {
		// ...
	}
}

通过继承，简化Student类的定义:

class Student extends Person {
	public String school;
}

Student类继承了父类Person的所有属性和方法，并增加了一个属性school。Person中的属性和方法,Student都可以使用。

为什么要有继承？

• 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。说白了就是让代码更加简洁，类似去重

此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”

类继承语法规则:
class Subclass extends SuperClass{ }

继承作用：

• 继承的出现减少了代码冗余，提高了代码的复用性。
• 继承的出现，更有利于功能的扩展。
• 继承的出现让类与类之间产生了关系，提供了多态的前提。

注意：不要仅为了获取其他类中某个功能而去继承

注意事项:
子类继承了父类，就继承了父类的方法和属性。
在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

关于继承的规则：

• 子类不能直接访问父类中私有的(private)的成员变量和方法。
  
• Java只支持单继承和多层继承，不允许多重继
  • 一个子类只能有一个父类
  • 一个父类可以派生出多个子类
    • class SubDemo extends Demo{ } //ok
    • class SubDemo extends Demo1,Demo2...//error
      

2、方法的重写(override/overwrite)

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求：

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
   • 子类不能重写父类中声明为private权限的方法
4. 子类方法抛出的异常不能大于父类被重写方法的异

注意：
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为
static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

举例:

 	public class Person {
        public String name;
        public int age;
        public String getInfo() {
            return "Name: "+ name + "\n" +"age: "+ age;
        }
    }
    
	public class Student extends Person {
        public String school;
        public String getInfo() { //重写方法
            return "Name: "+ name + "\nage: "+ age
                    + "\nschool: "+ school;
        }
        public static void main(String args[]){
            Student s1=new Student();
            s1.name="Bob";
            s1.age=20;
            s1.school="school2";
            System.out.println(s1.getInfo()); //Name:Bob age:20 school:school2
        }
    }

Person p1=new Person();
//调用Person类的getInfo()方法
p1.getInfo();
Student s1=new Student();
//调用Student类的getInfo()方法
s1.getInfo();
这是一种“多态性”：同名的方法，用不同的对
象来区分调用的是哪一个方法。

举例:

class Parent {
        public void method1() {}
    }
    class Child extends Parent {
        //非法，子类中的method1()的访问权限private比被覆盖方法的访问权限public小
        private void method1() {}
    }
    public class UseBoth {
        public static void main(String[] args) {
            Parent p1 = new Parent();
            Child c1 = new Child();
            p1.method1();
            c1.method1();
        }
    }

3、四种访问权限修饰符

Java权限修饰符public、protected、 (缺省)、 private置于类的成员定义前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	Yes
(缺省)	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

对于class的权限修饰只可以用public和default(缺省)。

• public类可以在任意地方被访问。
• default类只可以被同一个包内部的类访问。

4、关键字：super

在Java类中使用super来调用父类中的指定操作：

• super可用于访问父类中定义的属性
• super可用于调用父类中定义的成员方法
• super可用于在子类构造器中调用父类的构造器

注意：

• 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
• super的追溯不仅限于直接父类
• super和this的用法相像，this代表本类对象的引用，super代表父类的内存
  空间的标识

关键字super举例

 class Person {
        String name = "张三"; 
        protected int age;
        public String getInfo() {
            return "Name: " + name + "\nage: " + age;
        }
    }
    class Student extends Person {
        protected String name = "李四";
        private String school = "New Oriental";
        public String getSchool() {
            return school;
        }
        public String getInfo() {
            return super.getInfo() + "\nschool: " + school;
        }}
    public class StudentTest {
        public static void main(String[] args) {
            Student st = new Student();
            System.out.println(st.getInfo());
        }
      }

调用父类的构造器

• 子类中所有的构造器默认都会访问父类中空参数的构造器
• 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”
  ，且必须放在构造器的首行
• 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错

调用父类构造器举例

 public class Person {
        private String name;
        private int age;
        private Date birthDate;
        public Person(String name, int age, Date d) {
            this.name = name;
            this.age = age;
            this.birthDate = d;
        }
        public Person(String name, int age) {
            this(name, age, null);
        }
        public Person(String name, Date d) {
            this(name, 30, d);
        }
        public Person(String name) {
            this(name, 30);
        }
    }

    public class Student extends Person {
        private String school;
        public Student(String name, int age, String s) {
            super(name, age);
            school = s;
        }
        public Student(String name, String s) {
            super(name);
            school = s;
        }
        // 编译出错: no super(),系统将调用父类无参数的构造器。
        public Student(String s) {
            school = s;
        }
    }

this和super的区别

No.	区别点	this	super
1	访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	直接访问父类中的属性
2	调用方法	访问本类中的方法，如果本类没有此方法则从父类中继续查找	直接访问父类中的方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行

5、子类对象实例化过程

为什么super(…)和this(…)不能在同一个构造函数中出现？

因为在构造的时候只需要调用父类的super()作为初始化父类一次，如果super(…)和this(…)同时出现的话，那么就会出现初始化父类两次的不安全操作，因为当super(…)和this(…)同时出现的时候，在调用完了super(…)之后还会执行this(…)，而this(…)中又会自动调用super（）,这就造成了调用两次super()的结果(这是假设super(…)和this(…)同时出现时候，super(…)在this(…)前面，反过来出现也一样)

为什么super(…)或this(…)调用语句只能作为构造器中的第一句出现？

结论 也就是说你必须在构造器的第一行放置super或者this构造器，否则编译器会自动地放一个空参数的super构造器的，其他的构造器也可以调用super或者this，调用成一个递归构造链，最后的结果是父类的构造器（可能有多级父类构造器）始终在子类的构造器之前执行，递归的调用父类构造器。无法执行当前的类的构造器。也就不能实例化任何对象，这个类就成为一个无为类。

从另外一面说，子类是从父类继承而来，继承了父类的属性和方法，如果在子类中先不完成父类的成员的初始化，则子类无法使用，应为在java中不允许调用没初始化的成员。在构造器中是顺序执行的，也就是说必须在第一行进行父类的初始化。而super能直接完成这个功能。This()通过调用本类中的其他构造器也能完成这个功能。 因此，this()或者super()必须放在第一行。

举例:

class Creature {
    public Creature() {
        System.out.println("Creature无参数的构造器");
    }}
class Animal extends Creature {
    public Animal(String name) {
        System.out.println("Animal带一个参数的构造器，该动物的name为" + name);
    }
    public Animal(String name, int age) {
        this(name);
        System.out.println("Animal带两个参数的构造器，其age为" + age);
    }}
public class Wolf extends Animal {
    public Wolf() {
        super("灰太狼", 3);
        System.out.println("Wolf无参数的构造器");
    }
    public static void main(String[] args) {
        new Wolf();
    }
}
/**
*    
	Creature无参数的构造器
	Animal带一个参数的构造器，该动物的name为灰太狼
	Animal带两个参数的构造器，其age为3
	Wolf无参数的构造器
*/

6、面向对象特征之多态性

多态性，是面向对象中最重要的概念，在Java中的体现：
对象的多态性：父类的引用指向子类的对象

• 可以直接应用在抽象类和接口上

Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，

• “看左边”
  ：看的是父类的引用（父类中不具备子类特有的方法）
• “看右边”
  ：看的是子类的对象（实际运行的是子类重写父类的方法）

对象的多态 —在Java中,子类的对象可以替代父类的对象使用

• 一个变量只能有一种确定的数据类型
• 一个引用类型变量可能指向(引用)多种不同类型的对象

Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。

一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法

Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student(); 
e.school = “pku”; //非法,Person类没有school成员变量

属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编
译错误。

多态性应用举例
方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

    public class Test {
        public void method(Person e) {
			// ……
            e.getInfo();
        }
        public static void main(Stirng args[]) {
            Test t = new Test();
            Student m = new Student();
            t.method(m); // 子类的对象m传送给父类类型的参数e
        }
    }

虚拟方法调用(Virtual Method Invocation)

正常的方法调用

Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

多态性应用举例
方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

public class Wolf extends Animal {
    public Wolf() {
        super("灰太狼", 3);
        System.out.println("Wolf无参数的构造器");
    }
    public static void main(String[] args) {
        new Wolf();
    }
    public class Test {
        public void method(Person e) {
		// ……
            e.getInfo();
        }
        public static void main(Stirng args[]) {
            Test t = new Test();
            Student m = new Student();
            t.method(m); // 子类的对象m传送给父类类型的参数e
        }
    }

虚拟方法调用(Virtual Method Invocation)

正常的方法调用

Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法

编译时类型和运行时类型
 编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定

虚拟方法调用举例：

前提：
Person类中定义了welcome()方法，各个子类重写了welcome()。
执行：
多态的情况下，调用对象的welcome()方法，实际执行的是子类重写的方法。

小结：方法的重载与重写
从编译和运行的角度看：
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

多态小结
多态作用：

• 提高了代码的通用性，常称作接口重用

前提：

• 需要存在继承或者实现关系
• 有方法的重写

成员方法：

• 编译时：要查看引用变量所声明的类中是否有所调用的方法。
• 运行时：调用实际new的对象所属的类中的重写方法。

成员变量：

• 不具备多态性，只看引用变量所声明的类。

instanceof 操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

• 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
• 如果x属于类A的子类B，x instanceof A值也为true。

public class Person extends Object {…}
public class Student extends Person {…}
public class Graduate extends Person {…}
-------------------------------------------------------------------
public void method1(Person e) {
        if (e instanceof Person)
			// 处理Person类及其子类对象
        if (e instanceof Student)
			//处理Student类及其子类对象
        if (e instanceof Graduate)
			//处理Graduate类及其子类对象
        }

对象类型转换 (Casting )

基本数据类型的Casting：

• 自动类型转换：小的数据类型可以自动转换成大的数据类型
  如long g=20; double d=12.0f
• 强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
  如 float f=(float)12.0; int a=(int)1200L

对Java对象的强制类型转换称为造型

• 从子类到父类的类型转换可以自动进行
• 从父类到子类的类型转换必须通过造型(强制类型转换)实现
• 无继承关系的引用类型间的转换是非法的
• 在造型前可以使用instanceof操作符测试一个对象的类型

对象类型转换举例

public class ConversionTest {
    public static void main(String[] args) {
        double d = 13.4;
        long l = (long) d;
        System.out.println(l);
        int in = 5;
		// boolean b = (boolean)in;
        Object obj = "Hello";
        String objStr = (String) obj;
        System.out.println(objStr);
        Object objPri = new Integer(5);
		// 所以下面代码运行时引发ClassCastException异常
        String str = (String) objPri;
    }
}

public class Test {
    public void method(Person e) { // 设Person类中没有getschool() 方法
		// System.out.pritnln(e.getschool()); //非法,编译时错误
        if (e instanceof Student) {
            Student me = (Student) e; // 将e强制转换为Student类型
            System.out.pritnln(me.getschool());
        }
    }
    public static void main(String[] args){
        Test t = new Test();
        Student m = new Student();
        t.method(m);
    }
}

图解:

继承成员变量和继承方法的区别:

public class Base {
    int count = 10;
    public void display() {
        System.out.println(this.count);
    }
}

class Sub extends Base {
    public static void main(String[] args){
        Sub s = new Sub();
        System.out.println(s.count);
        s.display();
        Base b = s;
        System.out.println(b == s);
        System.out.println(b.count+"  "+s.count);
        b.display();
    }

    int count = 20;
    @Override
    public void display() {
        System.out.println(this.count);
    }
}

输出:

20
20
true
10  20
20

可以看出父类的变量没有被重写还是20

子类继承父类

• 若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的
  同名方法，系统将不可能把父类里的方法转移到子类中。
• 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的
  实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

7、Object类的使用

Object类是所有Java类的根父类

如果在类的声明中未使用extends关键字指明其父类，则默认父类
为java.lang.Object类

public class Person {
	...
}
等价于：
public class Person extends Object {
	...
}

例：method(Object obj){…} //可以接收任何类作为其参数
Person o=new Person();
method(o);

Object类中的主要结构

NO.	方法名称	类型	描述
1	public Object()	构造	构造器
2	public boolean equals(Object obj)	普通	对象比较
3	public int hashCode()	普通	取得Hash码
4	public String toString()	普通	对象打印时调用

==操作符与equals方法
基本类型比较值:只要两个变量的值相等，即为true。

int a=5; if(a==6){…}

引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才 返回true。

Person p1=new Person();
Person p2=new Person();
if (p1==p2){…}

用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本
数据类型除外)，否则编译出错

equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写。

• 只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。
• 格式:obj1.equals(obj2)
  特例：当用equals()方法进行比较时，对类File、String、Date及包装类
  （Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对
  象；
• 原因：在这些类中重写了Object类的equals()方法。

当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等

重写equals()方法的原则

• 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
• 自反性：x.equals(x)必须返回是“true”。
• 传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
• 一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你
  重复x.equals(y)多少次，返回都是“true”。
• 任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

== 和equals的区别

1. == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型
   就是比较内存地址
2. equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成了equals是比较值的错误观点。
3. 具体要看自定义类里有没有重写Object的equals方法来判断。
4. 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

toString() 方法

• toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
• 在进行String与其它类型数据的连接操作时，自动调用toString()方法

Date now=new Date();
System.out.println(“now=”+now); 相当于
System.out.println(“now=”+now.toString());

可以根据需要在用户自定义类型中重写toString()方法如String 类重写了toString()方法，返回字符串的值。

s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString());

• 基本类型数据转换为String类型时，调用了对应包装类的toString()方法

int a=10; System.out.println(“a=”+a);

8、包装类的使用

针对八种基本数据类型定义相应的引用类型—包装类（封装类）
有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

装箱:基本数据类型包装成包装类的实例

• 通过包装类的构造器实现：

int i = 500; Integer t = new Integer(i);

• 还可以通过字符串参数构造包装类对象：

Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException

拆箱:获得包装类对象中包装的基本类型变量

• 调用包装类的.xxxValue()方法：

boolean b = bObj.booleanValue();

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

字符串转换成基本数据类型

• 通过包装类的构造器实现：

int i = new Integer(“12”);

通过包装类的parseXxx(String s)静态方法：

Float f = Float.parseFloat(“12.1”);

基本数据类型转换成字符串

• 调用字符串重载的valueOf()方法：

String fstr = String.valueOf(2.34f);

• 更直接的方式：

String intStr = 5 + “”

总结：基本类型、包装类与String类间的转换

包装类用法举例

int i = 500;
Integer t = new Integer(i);

装箱：包装类使得一个基本数据类型的数据变成了类。
有了类的特点，可以调用类中的方法。

String s = t.toString(); // s = “500“,t是类，有toString方法
String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。
String s2=“4.56”;
double ds=Double.parseDouble(s2); //将字符串转换成数字

拆箱：将数字包装类中内容变为基本数据类型。

int j = t.intValue(); // j = 500，intValue取出包装类中的数据

包装类在实际开发中用的最多的在于字符串变为基本数据类型。

String str1 = "30" ;
String str2 = "30.3" ;
int x = Integer.parseInt(str1) ; // 将字符串变为int型
float f = Float.parseFloat(str2) ; // 将字符串变为int型