Java：面向对象（继承，方法的重写（overide），super，object类及object类中方法的重写，父子类代码块执行顺序）

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

继承：

1.继承是对某一匹类的抽象，从而实现对现实世界更好的建模。

2.提高代码的复用性。

3.extends（扩展），子类是父类的扩展。

4.子类继承父类可以得到父类的全部属性和方法。（除了父类的构造方法）。

5.java中只有单继承，没有像c++这种的多继承。多继承就是为了实现代码的复用性，但引入了复杂性，使系统之间的关系造成混乱。

6.java中的多继承，可以通过接口来实现。

7.如果定义一个类时，没有调用extends，则默认定义的父类是：Java.lang.Object。

8.不同的的叫法：超类，父类，基类，子类，派生类。

继承:

代表了一种is-a关系。如果说A是B，也就可以说A继承了B。

父类(SuperClass):更加通用。
* 可以子类中共有的特性和功能保存到父类中
* 优点:提高了代码的复用性。

public class Teacher {
private String name;
private int age;
private int wrokOfYear; public Teacher(String name, int age, int wrokOfYear) {
// super();
this.name = name;
this.age = age;
this.wrokOfYear = wrokOfYear;
} public Teacher() {
// super();
} // getter方法：取值
public String getName() {
return name;
} // setter方法:赋值
public void setName(String name) {
this.name = name;
} public int getAge() {
return age;
} public void setAge(int age) {
this.age = age;
} public int getWrokOfYear() {
return wrokOfYear;
} public void setWrokOfYear(int wrokOfYear) {
this.wrokOfYear = wrokOfYear;
} /**
* 自我介绍
*/
public void intro() {
System.out.println("同学们好,我是" + name + ",今年" + age + "岁,已经工作了" + wrokOfYear + "年");
} /**
* 授课
*/
public void giveLession() {
System.out.println("知识点讲解....");
System.out.println("知识点总结....");
}}

子类:更加具体
* 在java中使用extends关键字实现继承。
* 一旦两个两个类建立了继承关系，子类就可以拥有父类非私有的属性和方法。
* 子类无法继承父类的构造方法，但可以通过super关键字进行调用。
* 语法 [修饰符] class 子类 extends 父类{
*
* }

方法的重写（override）：一般发生在子类和父类之间

1.既可以继承父类的东西又可以灵活的扩充。

2.其实就是在子类中重新把父类的同名方法重新写一个进行覆盖。

3.重写方法必须和被重写方法有相同的方法名称，参数列表，返回值。

4.重写方法不能使用比被重写方法更严格的访问权限。

5.子类的修饰符范围>=父类的修饰符范围。

重写（override）和重载（overload）的区别：

* 1.重写一般发生在父子之间，重载一般在同一个类中。
* 2.重写要求方法名，返回值类型，参数列表必须与父类相同，并且修饰符范围大于等于父类方法的修饰符范围。
* 重载方法名相同，参数列表不同，与返回值类型及修饰符无关。
* 3.作用不同。
* 重载主要是为了提供一种同名方法不同参数的能力（可以让一个类用于多个同名的方法）
* 重写主要是为了结合多态使用，提高程序扩展性和可维护性。
*
* 注意:一旦子类重写了父类中的方法，创建子类实例后，调用子类重写后的方法。
*
* @Override:重写的注解，标注当前方法为重写父类的方法，必须满足重写的规则。
*/

super：

是直接父类对象的引用，可以通过 super来调用父类中被子类覆盖的方法和属性。

super和this其实都是隐式参数，super指当前父类，this指当前。

public class JavaTeacher extends Teacher{
public JavaTeacher(){ }
public JavaTeacher(String name,int age,int workOfYear){
super(name,age,workOfYear);//调用父类的构造方法
} //方法的重写(覆写)
public void giveLession() {
System.out.println("打开eclipse.....");
// System.out.println("知识点讲解.....");
// System.out.println("知识点总结.....");
super.giveLession();//使用super调用父类的方法。
}
}

public class Test {
public static void main(String[] args) {
JavaTeacher javaTeacher = new JavaTeacher("zhangsan",30,6);
javaTeacher.intro();
javaTeacher.giveLession();
System.out.println("************************************");
DBTeacher dbTeacher = new DBTeacher("lisi",33,9);
dbTeacher.intro();
dbTeacher.giveLession();
}
}

public class DBTeacher extends Teacher{
public DBTeacher(){ }
public DBTeacher(String name,int age,int workOfYear){
super(name,age,workOfYear);//调用父类的构造方法
} public void giveLession() {
System.out.println("打开oracle.....");
super.giveLession();//调用父类的方法
}
}

super调用父类中带参数的构造方法同时调用自身的属性进行赋值：

public TestCar(String bland,String size,int price,String color){
super(bland,size,price);
this.color=color;
}

任何类的构造函数中，若是构造函数的第一行代码没有显式的调用super(...);那么Java默认都会调用super();作为父类的初始化函数。所以你这里的super();加不加都无所谓。

public class AtWill {
public static void main(String[] args) {
Cat c = new Cat(); //---------------(1)
System.out.println("-------------------");
Cat c1 = new Cat("花花",4); //----------------(2)
}
private String color;
private int foot; public AtWill(){
System.out.println("我是父类无参数构造器");
} public AtWill(String color,int foot){
System.out.println("我是父类有参数构造器");
this.color = color;
this.foot = foot;
}
}
class Cat extends AtWill{ public Cat(){
// super(); //---------------可以省略，没有super也自动调用父类无参构造
System.out.println("我是子类无参数构造器");
} public Cat(String color,int foot){
//super(color,foot); //---------------(3)
// super(); //---------------可以省略，调用的父类无参构造
System.out.println("我是子类有参数构造器");
}
}
/**
* 我是父类无参数构造器
我是子类无参数构造器
-------------------
我是父类无参数构造器
我是子类有参数构造器
*/

*java.lang.Object类:所有类的基类
*一个类如果没有显式使用extends继承其他类，这个类继承了Object类，在任何类的对象中使用Object中的方法
*public class Student{
*}
*public class Student extends Object{
*}
*常用的方法:
* getClass() 返回此 Object 的运行时类。主要用于反射机制。
* toString() 返回该对象的字符串表示。如果使用System.out.println(stu);默认调用stu.toString()
* cn.zzsxt.oop6.Student@26ffd553==》
* cn.zzsxt.oop6.Student(包名.类名)+@+16进制表示的hashcode码
* toString()方法经常在子类中重写。
*
*/

public class Student {
String name;
int age;
public Student(){ } public Student(String name,int age){
this.name=name;
this.age=age;
} @Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
} public static void main(String[] args) {
Student stu = new Student("张三",);
// Student stu2 = new Student();
// String str = stu.toString();
// String str2 = stu2.toString();
// System.out.println(str);
// System.out.println(str2);
System.out.println(stu);//默认调用对象的toString();
System.out.println(stu.toString());
}
}

重写object中equals方法：

public class Student {
String name;
int age;
public Student(){ }
public Student(String name,int age){
this.name=name;
this.age=age;
}
/**
* 重写Object中equals方法
*/
@Override
public boolean equals(Object obj) {
Student stu = (Student)obj;//强转？
if(name.equals(stu.name)&&age==stu.age){
return true;
}else{
return false;
}
}}

/**
* ==和equals的区别
* ==在比较内容时分为以下两种情况:
* 1.使用==比较基本数据类型，做的值的比较,值相同返回true，否则返回false
* 2.使用==比较引用类型，比较不是内容是否相同，而是两个对象的引用(地址)是否相同，
* 如果指向相同的地址返回true，否则返回false。
* equals():比较内容是否相同。
* Object中的equals方法本质比较引用(==),如果需要按照内容进行比较是否相同，就需要重新Object中equals方法。
*/
public class TestEquals {
public static void main(String[] args) {
Student stu = new Student("zhangsan",);
Student stu2 = new Student("zhangsan",);
System.out.println(stu==stu2);//比较stu和stu2是否指向相同的地址。
System.out.println(stu.equals(stu2));//
}
}

父类和子类中代码的执行顺序
* 静态代码块在使用类时执行。
* 普通代码块在创建对象时执行。
* 父类的静态代码块>子类静态代码块>父类的代码块>父类的构造方法>子类的代码块>子类的构造方法
* 在创建子类时，先调用父类的构造方法先创建父类的实例，在创建子类的实例。

public class Child extends Parent{
{
System.out.println("Child....代码块1");
}
static{
System.out.println("Child...static1....");
}
public Child(){
super();
System.out.println("Child()....");
}
{
System.out.println("Child....代码块2");
}
static{
System.out.println("Child...static2....");
} public static void main(String[] args) {
Child child = new Child();
}
}

public class Parent {
{
System.out.println("Parent....代码块");
}
static{
System.out.println("Parent...static1.....");
} public Parent(){
System.out.println("Parent().....");
} {
System.out.println("Parent....代码块2");
}
static{
System.out.println("Parent...static2.....");
}}