继承

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

2.extands的意思是“扩展”，子类是父类的扩展

3.java中类只有单继承，没有多继承

• 一个子类只能有一个父类，一个父类可以有多个子类

4.继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

5.继承关系的两个类，一个为子类(派生类)一个为父类(基类)。子类继承父类，使用关键字extands来表示

6.子类与父类之间，从意义上讲应该具有“is a”的关系

7.Object类：在java中所有的类，都默认或间接继承Object类，Object是继承中最高的类(Ctrl + H可以查看继承关系)

8.super:在子类中，可以用super访问父类的成员变量和成员方法

9.方法重写

10.修饰符权限：public (私有)---->protected(保护)—>default(不写)---->private(私有)

**例子1：**子类可以使用父类的变量和方法

// Person 人:父类
public class Person /*extends Object*/{

protected String name="父类成员变量";
}

===================================分开===================================

//学生 is 人:子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
}

===================================分开===================================
//测试类
public class Application {
public static void main(String[] args)
{
Student student = new Student(); //创建子类对象
System.out.println(student.name); //父类成员变量
}
}

分析：子类中没有任何的变量和类，但是在对象引用的时候，可以使用父类的成员变量。

子类可以使用父类的所有变量和方法，私有的变量和方法无法被继承

**例子2：**所有类都默认和间接继承Object类

//在java中，所有的类，都默认直接或间接继承Object
// Person 人:父类
public class Person /*extends Object*/{
}

===================================分开===================================
//测试类
public class Application {
public static void main(String[] args)
{
Person person = new Person();
person.getClass();
person.hashCode();
}
}

在Person类中，什么都没有写，但是person对象却可以使用Object类中的方法，证明了所有类都默认和间接继承Object类

super详解

**例子1：**子类中：调用(内部变量和内部方法)、(子类变量和子类方法)、(父类变量和父类方法)

//在java中，所有的类，都默认直接或间接继承Object
// Person 人:父类
public class Person /*extends Object*/{
protected String name="父类成员变量";

public void print(){
System.out.println("person");
}
}

===================================分开===================================
//学生 is 人:子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{

protected String name="子类成员变量";

public void print(){
System.out.println("Student");
}

public void test1(){
//子类中调用：内部方法，子类方法，父类方法
print();  //内部方法
this.print(); //子类成员方法
super.print();	//父类成员方法
}

public void test(String name){
//在子类中，调用内部变量，子类成员变量，父类成员变量
System.out.println(name); //使用内部变量
System.out.println(this.name); //使用子类成员变量
System.out.println(super.name);//使用父类成员变量
}

}

===================================分开===================================
//测试类
public class Application {
public static void main(String[] args)
{
Student student = new Student();
student.test("子类局部变量"); //子类局部变量	子类成员变量	父类成员变量
student.test1(); //Student	Student	person
}
}

分析：分别使用了super调用父类变量和方法、this调用本类变量和方法

**例子2：**子类构造方法使用super调用父类的构造方法

//在java中，所有的类，都默认直接或间接继承Object
// Person 人:父类
public class Person /*extends Object*/{
public Person(){
System.out.println("Person无参执行了");
}
}

===================================分开===================================
//学生 is 人:子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
public Student(){

//隐藏代码：调用了父类的无参构造super();
super(); //调用父类的构造器，必须要在子类的第一行
System.out.println("Student无参执行了");
}
}

===================================分开===================================
//测试类
public class Application {
public static void main(String[] args)
{
Student student = new Student();
// Person无参执行了
//Student无参执行了
}
}

分析：1.从结果来看，是先执行了父类构造方法，然后才执行了子类构造方法。子类的构造方法中隐藏代码：调用了父类的无参构造方法super();

2.super调用父类构造器，必须在子类构造器的第一行。

3.this调用子类的构造器，必须在子类构造器的第一行。

4.父类中创建有参的构造方法，子类中也必须调用父类的有参构造方法

super注意点：

• super调用父类的构造方法，必须在构造方法的第一个
• super必须只能出现在子类的方法中或者构造方法中
• super和this不能同时调用构造方法

super和this对比

1.代表的对象不同：

• this：本身调用这个对象
• super:代表父类对象的应用

2.前提

• this：没有继承也可以使用
• super：只能在继承条件下才能使用

3.构造方法：

• this()；本类的构造
• super()；父类的构造

方法重写

重写：需要有继承关系，而且是子类重写父类的方法！

1.方法名必须相同

2.参数列表也必须相同

3.修饰符：范围可以扩大:public (私有)---->protected(保护)—>default(不写)---->private(私有)

4.抛出的异常：范围，可以被缩小，但不能扩大

重写，子类的方法和父类的方法必须要一致，方法体不同

为什么需要重写：

1. 父类的功能，子类不一定需要，或者不一定满足

   Alt + Insert : override;

不能被重写的方法

static 方法，属于类，它不属于对象

final 常量

private 方法，私有的，属于类

例子1：

//重写都是方法的重写，和属性无关
public class B {

public static  void test(){
System.out.println("B=>test()");
}
}

===================================分开===================================
//子类
public class A extends B{

public static void test() {
System.out.println("A=>test()");
}
}

===================================分开===================================
//测试类
public class Application {
//静态的方法和非静态的方法区别很大!
public static void main(String[] args)
{
//方法的类型只和左边，定义的数据类型有关
A a = new A();
a.test(); //A

//父类的引用指向了子类
B b = new A();
b.test(); //B
}
}

结果：

A=>test()

B=>test()

1.在子类重写父类的方法，在方法中有static ，所以方法的类型只和左边，定义的数据类型有关

2.因为有静态方法，类一加载就出来了，重写没有用

3.下面去掉statci看下面的例子，成功重写

例子2；

//重写都是方法的重写，和属性无关
public class B {

public void test(){
System.out.println("B=>test()");
}
}

===================================分开===================================
//子类
public class A extends B{

//Override 重写
@Override //注解：有功能的注释
public void test() {
System.out.println("A=>test()");
}
}

===================================分开===================================
//测试类
public class Application {
//静态的方法和非静态的方法区别很大!
public static void main(String[] args)
{
//方法的类型只和左边，定义的数据类型有关
A a = new A();
a.test(); //A

//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法
b.test(); //B
}
}

结果：

A=>test()

A=>test()

分析：静态的方法和非静态的方法区别很大!