1.为什么需要继承？如何继承？继承到什么？ 2.方法的重载与重写的区别 3.类型的自动转换和强制转换 4.子类特有的方法的调用规则 5.子类重写的方法的调用规则 6.多态的理解 7.面向对象的三大特征

注：自己总结的，可能有些不足，但第一次上Java课，有错希望可以帮忙指出，感激不尽

1.继承的概念？为什么需要继承？如何继承？继承到什么？

继承的概念？

可以基于已经存在的类构造一个新类。继承已经存在的类就可以复用这些类的方法和域。在此基础上，可以添加新的方法和域，从而扩充了类的功能。继承在本质上是特殊和一般的关系，即常说的is-a关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的一些属性或方法。继承是利用现有的类创建新类的过程，现有的类称作基类（或父类），创建的新类称作派生类（子类）。

为什么需要继承？

1.为了体现现实中类之间的关系

2.减少代码冗余

3.对父类实现修改和扩展

如何继承？

public class B extends A{}

表示B类继承了A类，B类是A类的子类

继承到了什么？

1.继承到了可访问的属性和方法

2.子类可以定义自己特有的属性和方法【必须是子类类型的对象才能调用】

3.子类可以重写[覆盖]从父类继承来的属性和方法【根据对象new的是什么类型，就调用那个类中的方法】





实现继承代码示例：

class Person { 

  public String mName; 

  public int mAge;     

  public void dining() {

System.out.println("吃饱了...");

}

}

class Student extends Person { 

  public float mGrade; 

  public void examination() {

System.out.println("考试及格了...");

} 

}

public class A { 

  public static void main(String[] args) {

    Student std = new Student();       

    std.mName = "张三";  std.mAge = 18; 

    std.dining();                      

    std.examination();               

  }

}

继承中构造方法的示例：

class ParentClass {  //定义父类

  public ParentClass() {  //构造方法

    System.out.println("这是父类的构造方法。");

  }

}

class ChildClass extends ParentClass {  //子类继承于父类

  public ChildClass() {  //构造方法

    System.out.println("这是子类的构造方法。");

  }

}

public class ConstructorTest {  //该类用于容纳main方法

  pub
4000
lic static void main(String[] args) {

    ChildClass cc = new ChildClass();  //实例化子类对象

  }

}

得到的结果是：当实例化子类的对象时，必须先执行父类的构造方法，再执行子类的构造方法， 如果父类的构造方法实例化失败，子类的也会失败。

注：父类的构造方法是不能被子类继承的，即使是public

2.方法的重载与重写的区别

方法的重写：在子类中修改从父类中继承来的方法

方法名，参数列表，返回值都必须一样

访问限定符不能缩小

代码示例：

class Person { 

  public String mName; 

  public int mAge;     

  public void dining() {

System.out.println("吃饱了...");

}

}

class Student extends Person { 

  public float mGrade; 

  public void dining() {

System.out.println("没吃饱...");

} 

}

方法的重载：在同一个类中，有多个同名不同参数列表的方法

重载和方法的访问限定符，返回值没有关系

代码示例：

class Person { 

  public String mName; 

  public int mAge;     

  public void dining(int a,String b) {

System.out.println("吃饱了...");

}

public void dining(int a){

System.out.println("好好学习...");

}

}

3.类型的自动转换和强制转换

自动转型(类型向上自动转换)：子类对象的类型可以自动转成父类类型

强制转型(类型向下强制转换) : 将父类类型的对象强制转换成子类类型

代码示例：

class Person { 

  public String mName; 

  public int mAge;     

  public void dining() {

System.out.println("吃饱了...");

}

}

class Student extends Person { 

  public float mGrade; 

  public void examination() {

System.out.println("考试及格了...");

} 

}

public class A { 

  public static void main(String[] args) {

   Person std = new Student();  //自动转换

Student std1 = new Student();

std1=(Student)std;//强制转换     

    std.mName = "张三";  std.mAge = 18; 

    std.dining();                      

    std.examination();               

  }

}

4.子类特有的方法的调用规则

class A

{

        public static void main(String[] args){

                Animal a = new Cat();//类型提升，向上转型。

                a.eat();//但是不能使用子类的特有方法。

                //如何使用子类特有方法呢？

                //可以强制将父类的引用转换成子类类型。

                Cat c = (Cat)a;//向下转型

                c.CatchMouse();

                //下面这种转型是不对的。我们转的是父类的引用，不可以将父类的对象转型。

                //我们可以转换的是父类的引用指向的自己的子类对象时，可以被提升，也可以被 强制转换。

                //多态自始至终都是子类对象在变化

                Animal a = new Animal();

                Cat  c = (Cat)a;

        }

}

通过以上代码可以总结出：类型向上转型是不用强制类型转换的，向下转型需要强制类型转换，但是向下转型必须是父类类型的对象new子类的空间，如果直接强制类型转化父类的对象是不对的

5.子类重写的方法的调用规则

public class Parent {

        //父类方法

        void who() {

            System.out.println("I'm parent");

        }

    }

 

    public class Child extends Parent {

        //子类重写方法

        void who() {

            System.out.println("I'm child");

        }

        //通过super调用父类方法

        void parentWho(){

            super.who();

        }

    }

 

    public static void main(String[] args)  {

        Child child =  new Child();

        Parent parent =  new Parent();

        parent.who();

        child.who();

        child.parentWho();

    }

运行结果：I'm parent I'm child I'm parent

如果是 Parent parent =  new Child();能不能用看parent是什么类型的，调用谁看new的是哪个类的

6.多态的理解

多态：相同类型的对象，调用相同的方法，得到的结果可能不一样

静态多态：方法的重载导致的

动态多态: 方法的重写导致的

代码示例：

public class Demo{

public static void main(String[] args){

Student stu = new Student();

stu.setName("张三");

stu.study();

//类型向上自动转换：子类对象的类型可以自动转成父类类型

Student stu3 = new UNStudent();//父类类型的子类对象

stu3.setName("王五");

stu3.study();//和上面的一样是同一类型的对象，调用相同方法，得到的结果不同

//类型向下强制转换:将父类类型的对象强制转换成子类类型

//可能出现逻辑错误

UNStudent stu4 = (UNStudent)stu3;

//stu4.study();

Teacher t = new Teacher();

t.teach(stu2);

}

}

7.面向对象的三大特征

三大特征：继承、多态、封装

详细了解各自的含义

封装：也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

继承：继承是指这样一种能力，它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。一般情况下一个子类只能继承一个基类。

多态：相同类型的对象，调用相同的方法，实现不同的状态。

实现多态有两种方式：覆盖（动态多态），重载（静态多态）。

它们各自的作用？

封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了代码重用。而多态则是为了实现另一个目的接口重用。多态的作用就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。

8.继承中的this和super

this：构造方法中的this表示当前正在初始化的对象引用，方法中的this表示当前正在调用此方法的对象引用。this具体用法表现在一下几个方面：

1.当有多个重载的构造方法时，且一个构造方法需要调用另外一个构造方法，在其第一行使用this形式调用，且只能在第一行；

2.当对象中一个方法需要调用本对象中其他方法时，使用this作为主调，也可以不写，实际上默认就是this作为主调；

3.当对象属性和方法中的局部变量名称相同时，在该方法中需要显式的使用this作为主调，以表示对象的属性，若不存在此问题，可以不显式的写this。

super：表示调用父类中相应的属性和方法。在方法中，若需要调用父类的方法时，也一定要写在第一行。在Java中，super关键字有两个主要用途

第一种用途是：在子类的构造方法中，super关键字可以显式地调用父类的构造方法，用于将参数传递给它；其一般语法是：super(实际参数);

需要注意的是：该语句必须是子类构造方法的第一条语句。

第二种用途是：如果父类和子类中有同名成员，在子类中默认访问是属于自己的那一个成员；

super关键字可以明确地指定要访问父类中的成员；其一般语法是：super.成员名;

前提条件是：父类中的该成员不是private的。这两种用途都和父类有关。