黑马程序员 Java继承

 

Java继承通过extends关键字实现

class  PersonDemo 
{ 
    public static void main(String[] args)  
    { 
        Student student1=new Student("张三",21); 
        student1.speak(); 
        Worker worker1=new Worker("李四",24); 
        worker1.speak(); 
    } 
} 
class Person 
{ 
     int age; 
     String name; 
} 
class Student extends Person 
{ 
    Student(String name,int age) 
    { 
        this.name=name; 
        this.age=age; 
    } 
    public void speak() 
    { 
        System.out.println("我是一名学生，我的名字是："+name+"我的年龄是："+age); 
    } 
} 
class Worker extends Person 
{ 
    Worker(String name,int age) 
    { 
        this.name=name; 
        this.age=age; 
    } 
    public void speak() 
    { 
        System.out.println("我是一名工人，我的名字是："+name+"我的年龄是："+age); 
    } 
}

 

• 方法重写

class JiChengDemo2 
{
    public static void main(String[] args) 
    {
        Parent p1=new Parent();
        p1.show();//父类方法
        Child c=new Child();
        c.show();//子类方法

    }
}
class Parent
{
    public void show()
    {
        System.out.println("父类方法！");
    }
}
class Child extends Parent
{
    public void show()
    {
        System.out.println("子类方法！");
    }
    
}

•  构造函数

1.在对子类对象进行初始化时，父类空参数的构造函数也会运行因为子类构造函数默认第一行有一条隐式的语句super()
2.子类的空参数的构造函数手动定义了super()来访问父类指定的构造函数时，将不会存在隐式的super()语句。
3.子类的构造函数可以手动定义this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中的构造函数

public class ExtendsTest {
    public static void main(String args[])
    {
        Student s= new Student();
        s.getAge();
    }

}
class Person
{
    private int age;
    private String name;
    Person()
    {
        System.out.println("Person类");
    }
    Person(int age,String name)
    {
        this.age =age;
        this.name=name;
    }
    public void getAge()
    {
        System.out.println("年龄是："+age);
    }
    public void getName()
    {
        System.out.println("名字是："+name);
    }
}
class Student extends Person
{
    Student()
    {
        this(12, "张三");
    }
    Student(int age,String name)
    {
        super(age,name);
        System.out.println("Student类");
    }
    
    
}

 

final关键字可以修饰变量，类，方法。它用于表示它修饰的类，变量，方法是不变的。

• final变量

系统不会对final成员属性进行默认初始化成员变量只能在定义该成员变量时指定默认值，或者在静态代码块，构造代码块中指定初始值

class FinalDemo 
{
    public static void main(String[] args) 
    {
        Person p=new Person();
        System.out.println(p.age);
        System.out.println(p.name);
    }
}
class Person
{
    final int age;
    final static String name;
    {
        age=15;
    }
    static
    {
        name="张三";
    }
}

final可以先声明而不给初值。

class FinalDemo 
{
    public static void main(String[] args) 
    {
        Person p =new Person("张三");
        System.out.println(p.name);
    }
}
class Person
{
    public final String name;
    Person(String name)
    {
        this.name=name;
    }
}

 

final修饰引用类型的变量，它保存的仅仅是一个引用。final只保证这个引用所引用的地址不会变。对象完全可以发生改变

• final方法

final修饰方法不可以被重写

• final类

final修饰类不可以被继承

• static和final一块用表示什么 

  static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 
  对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 
  对于方法，表示不可覆盖，并且可以通过类名直接访问。 

• 不可变类

不可改变类：该实例的属性是不可改变的。Java提供的8个包装类和String都是不可改变类。

创建自定义的不可变类，可遵守如下规则

1. 使用private和final修饰符来修饰该类的属性
2. 提供带参构造函数，用来根据传入参数来初始化类里的属性。
3. 为该类的属性提供get方法,不要为该类的属性提供set方法，因为普通方法无法修改final修饰的属性
4. 如果有必要，重写Object类中hashCode和equals方法，在equals方法根据关键属性来作为两个对象相等的标准，除此之外，还应该保证两个用equals方法判断为相等的对象的hasCode也相等。

抽象类和抽象方法

抽象类和抽象方法的规则如下：

• 抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。
• 抽象类不能被实例化，无法使用new关键字来调用抽象类的构造函数来创建抽象类的实例。即使抽象类里不包含抽象方法，这个抽象类不能创建实例。
• 抽象类可以包含属性、方法、构造函数、初始化快、内部类、枚举类、六种成分。抽象类的构造器不能用于创建实例。主要是用于被子类调用。
• 抽象类内不一定有抽象方法，抽象方法一定在抽象类中。
• 如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象方法。

接口使用interface关键字来定义。接口内只包含抽象方法，不包含普通方法。 接口的属性只能是常量。因此系统会自动为这些属性增加 public static final两个修饰符，也就是说，在接口中定义属性时，不管是否使用 public static final修饰符，接口里的属性总将使用这三个修饰符来修饰。而且接口里没有构造函数和构造代码块。 接口的继承接口支持多继承 interface InterfaceC extends InterfaceA, InterfaceB 使用接口实现使用关键字implements