1：继承与构造方法
Child c = new Child();
要想创建子类，则必须先创建父类。
当创建子类的实例时，会先调用父类的构造方法，将这个类的字节码加载到内存中。
package cn.demo;
import org.junit.Test;
public class Demo01 {
public void test1(){
Grandpa g = new Child(); //父类的变量指向子类的实例 回首先调用父类的构造方法
//在此处是child—father-grandpa
}
}
class Grandpa {
public Grandpa() {
System.err.println("Grandpa..."+this);//this永远是指new的对象内存地址值，即引用
}
}
class Father extends Grandpa {
public Father() {
System.err.println("Father.."+this);
}
}
class Child extends Father {
public Child() {
System.err.println("Child.."+this);
}
}
输出：
Grandpa...cn.demo.Child@514713
Father..cn.demo.Child@514713
说明：
1：实例化子类时，会先调用父类的默认的构造方法。即先会加载父类。
2：此时在任意的位置(非静态的方法)中使用的this表示的是new的那个对象。
2：Super关键字 – 与this一样只能用于非静态的方法中
用法1：
调用被隐藏的成员变量。
调用被重写的成员方法。
class Grandpa {
public String name = "Grandpa";
public void say(){
System.err.println("name is:"+name);
}
}
class Father extends Grandpa {
public String name = "Father";//如果子类的成员变量与父类的成员量重名，此时父类的成员变量叫被隐藏了 //重写
@Override
public void say() {
System.err.println("father name is:"+name);//Father name is : Father
//如果希望访问父类的成员变量则可以在非静态的方法里面使用super关键字
System.err.println("grandpa is :"+super.name);//Grandpa is Grandpa
//当然也可以调用父类被重写的方法
super.say();//name is grandpa
}
}
输出：
father name is:Father
grandpa is :Grandpa
name is:Grandpa
用法2：
在子类的构造方法的第一句调用父类的某个构造。
class One {
public One(String name) {
}
}
/**
* 当父类没有默认构造时 如果实例化子类，子类又要调用父类的默认的构造 因为父类又没有默认的构造，所以子类出错
* 此时，子类必须要手工的添加一个任意的构造，且在构造方法的第一句 显式调用父类的某个有参数的构造
*/
class Two extends One {
public Two() { //在子类的构造中，必须要调用父类的某个构造
super("Jack");//
}
public Two(String nnm){
super("Mary");
}
}
3：final关键字
修饰的对象 | 功能 | 示例： |
可以修饰局部变量
当修饰局部变量 如果局部变量是数组则整个的数组不能再指向新的地址，但是里面的值是可以修改的： | 这个变量不能再指向新的地址 |
|
可以修饰成员方法 当修饰非静态的方法时，说明这个方法子类不能重写。 | public class Demo03 { @Test public void test1(){ ATwo t = new ATwo(); t.say();//只能调用父类的 } }
class AOne{ //此方法是最后的，不能被子类重写 public final void say(){ System.err.println("ddddd"); } } class ATwo extends AOne{ } | |
Final可以修饰类 表示这个类不能有子类 |
|
Fnal可以修饰：
成员变量
局部变量
类
成员方法。
[
其他的所修饰符号，能不修改局部变量，只有final可以修饰局部变量。
}
4：final与private
Final修饰的类不能有子类,但是可以被实例化。
用private修饰的构造，不能拥有子类，也不可以被实例化.
5：抽象类
抽象关键字是： abstract 。
被abstract修饰类叫抽象类。
特点：
1：抽象类不能被new实例化。
/**
* 声明一个抽象类
*/
abstract class Animal{
}
以下是错误的; new Animal();
2：抽象类可以拥有抽象方法
[抽象方法，是使用了abstract修饰的方法]
抽象方法不能有方法体：方法后面加上{}即被视为有方法体
Public abstract void say();
3:抽象类可以有抽象方法。也可以没有抽象方法。
abstract class Animal{
//此方法是非抽象的
public void say(){
}
//抽象
public abstract void run();
}
4：抽象方法必须要在抽象类里面。
5:当一个类继承抽象类时，必须要实现（重写）所有父类中的抽象方法
abstract class Animal{
//此方法是非抽象的
public void say(){
}
//抽象
public abstract void run();
public abstract void hi();
}
class Dog extends Animal{
@Override
public void run() {
}
@Override
public void hi() {
}
}
5：抽象类可以拥有构造方法。
说明：
抽象类，就是用于让子类继承的。
要求子类必须要实现某些方法，【定义的些规范】
限制：
Abstract关键字：不能修饰成员变量。只能修饰成员方法与类。
Abstract不能与private共同使用。不能与static共同使用。不能与final共同 。
小结：
抽象类就是被abstact修饰的类。此类不能被实例化。
被abstract修饰的方法，就抽象方法，不能有方法体系，必须要在抽象类里面。
6：接口
接口是被
Interface声明的类。
interface IOne{
}
2：也不能被实例化。
New Ione();错误的。
3：接口中的所有方法，默认都是：
Public abstract的
interface IOne{
public abstract void say();
}
4:里面的所有成员变量默认都是
Public static final的 – 静态常量 ，必须要声明时或在static代码块中设置值
interface IOne{
public static final int AGE=34;
void say();
}
5：在接口中不能有任何的实现
即
{
…可以被执行的代码
}
6：接口位于类层次的最上层
用于让子实现实现
interface IOne{
public static final int AGE=34;
void say();
void hi();
}
//一个类实现一个接口，也可以实现多个接口
class One1 implements IOne{
public void say() {
}
public void hi() {
}
}
7：一个具体类可以实现多个接口
interface IOne{
public static final int AGE=34;
void say();
void hi();
}
interface ITwo{
public void run();
}
//class SomeClass extends 亲爹 implements 叔叔1，姑姑,....
//一个类实现一个接口，也可以实现多个接口
class One1 implements IOne,ITwo{
public void say() {
}
public void hi() {
}
@Override
public void run() {
}
}
8：接口不能有构造 – 因为不能有任意的实例体所以不能有构造