day17_javaExtends

今日内容
继承

继承:
1.场景:
           如果多个类存在相同的属性和行为时,将这些内容抽取到单独一个类中,
           那么多个类无需再定义这些属性和行为,只要继承那一个类即可。
           其中,多个类可以称为子类,单独的那个类称为父类、超类、基类
           继承描述的是事物之间的所属关系,这种关系是:is-a的关系。
           父类更通用,子类更具体。我们主要是通过继承,可以使事物之间形成一种关系体系。
2.定义:
           就是子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。
           子类可以直接访问父类中的非私有的属性和行为。
3.好处:
        1.提高代码的复用性。
        2.使得类与类之间产生了关系,是多态的前提。
4.继承格式:
           通过关键字extends,可以声明一个子类继承另一个父类
            

class SuperClass{
            ....
                } 
class Subclass extends SuperClass{
            ....
             }

5. 继承后的特点---成员变量
        1.成员变量不重名
           如果子类父类中出现不重名的成员变量,这时访问时没有影响的。
           如果重名,这时访问是受影响的。
           子父类中出现了同名的成员变量时,在子类中需要访问父类中非私有成员变量,就需要使用super关键字,
           修饰父类成员变量,类似于关键字this
        2.使用格式:
           super.父类成员变量名;
备注:父类中的成员变量是非私有的,子类才可以直接访问。若父类中的成员变量私有了,子类不能直接访问的。
通常编码时,我们一般遵循封装的原则,可以在父类中提供公共的setXxx()和getXxx()方法。
6. 继承后的特点---成员方法
        1.成员方法不重名
           如果子类父类中出现不重名的成员方法时,这时的调用没有任何的影响。
           对象调用方法时,会先在子类中查找有没有对应的方法,若子类存在就会执行子类中的成员方法,
           若不存在就会执行父类中相应的方法。
        2.成员方法重名---重写(Override)
           方法重写:子类出现于父类一模一样的方法时(返回值类型,方法名和参数列表都相同),会出现覆盖效应
           也称为重写或者复写。声明不变,重新实现。
        3.重写的应用
           子类可以根据需要,定义特定于自己的行为,即沿袭了父类的功能名称,又能根据子类的需要重新实现父类
           的方法,从而进行扩展增强。比如:新的手机来电显示功能。
备注:
        1.子类方法重写覆盖父类方法时,必须保证权限大于等于父类的权限。
        2.子类方法重写父类方法时,返回值类型,方法名和参数列表必须一模一样。
在没有使用@Override时,子类定义父类方法时,方法名和参数列表可变,返回值类型不可变。
7. 继承的特点:
         1.java只支持单继承,不支持多继承。
         2.java支持多层继承(继承体系)
         3.子类和父类是一种相对概念。
备注:顶层父类是Object类,所有的类默认都继承Object类。
抽象类
        本质就是类
异同点:
使用场景:
        父类中的方法,被它的子类们重写,子类各自的实现都不尽相同。那么父类的方法声明和方法主体,
        只有声明还有意义,而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。
        Java语言规定,包含抽象方法的类必须是抽象类。
定义:
        抽象方法:没有方法体的方法。
        抽象类: 包含抽象方法的类。
        抽象方法和抽象类的声明需要用到关键字abstract(抽象的)。
        如果一个成员方法被abstract关键字修饰,那么该方法就是一个抽象方法,抽象方法只包含一个方法名,
        而没有方法体。
定义格式:
        修饰符 abstract 返回值类型 方法名(参数列表);
        如:

public abstract void eat(double money);

抽象类
        如果一个类包含了抽象方法,那么该类必须是抽象类
定义格式:

public abstract class ClassName {
//.....
......
}

抽象的使用:
        继承抽象类的子类必须重写父类中的所有的抽象方法,否则该子类也必须声明为抽象类。
        最终,必须有子类实现该父类的抽象方法,否则,从最初的父类到最终的子类都不能创建对象,失去了意义。
        抽象类一般被设计成父类使用的。

TestExtends

package com.buli.Extends;

public class TestExtendsDemo01 {

    public static void main(String[] args) {
        // 构建一个Teacher类的对象
        Teacher teacher = new Teacher();
        // 给该员工类的name属性进行赋值
        //teacher.name = "小明";
        // 调用该员工类的printName方法
        teacher.printName();
        teacher.job();
        teacher.work();
    }
}

Teacher

package buli.Extends;

// 定义讲师类Teacher 继承  员工类 Employee
public class Teacher extends Employee{
    
    // 在子类中再次定义name属性
    String name = "小王";
    // 定义一个打印name的方法
    public void printName() {
        System.out.println("name = " + super.name);
        System.out.println("name = " + this.name);    
    }
    // 重新再次定义一个work方法  增强编译性
    public void work() {    
    }
    // 定义一个工作的方法
    public void job() {    
        System.out.println("开心的快乐的工作着。。。");
    }
    // 定义一个打印age的方法
    public void printAge() {
        //System.out.println("age = " + age);
    }
}

Super

package buli.Extends;
/*
 *   super关键字   父,超,基
 *        定义:子类对父类的引用,只能在非静态方法中使用。
 *        1.引用父类的成员变量时 格式为:super.成员变量名
 *        2.引用父类的非静态方法时,格式为:super.方法名(参数列表)
 *        3.引用父类的构造方法时,    格式为:super(参数列表);
 *          super(参数列表)只能在构造方法中使用,而且必须是构造方法的第一条语句。
 */
public class SuperDemo extends Employee{
    
    String name = "小王";
    
    // 普通的成员方法
    public void method() {
        System.out.println(this.name);
        super.name = "张三";
    }
    
    public void method02(String name) {
        
        super.name = name;
        System.out.println(super.name);
    }
    
    public SuperDemo() {
        super();
        System.out.println("我要开始构造对象了。。。");
    }
    // Constructor call must be the first statement in a constructor
    public void method03() {
        //super();
    }
    public static void main(String[] args) {
        // 只能通过对象访问
        SuperDemo superDemo = new SuperDemo();
        //superDemo.method();        
        superDemo.method02("王五");
        //System.out.println(this.name);
    }
}

static

package com.buli.Extends;

// static关键字  单行注释
/*
     多行注释
 
 */
/**
    文档注释
    1.static关键字 可以用来修饰成员变量和成员方法,不能用来修饰类
         被修饰的成员是属于类的,而不单单是属于某一个对象的,将来调用这些被static修饰的成员信息,
         可以不再通过对象来调用。
    2.当static修饰成员变量时,该变量称为类变量。该类的每个对象都共享同一个类变量的值。
          任何对象都可以更改该类变量的值,但也可以在不创建对象的情况下对类变量进行操作。
          定义格式:
              static 数据类型   变量名;    如 static String name = "小刘";
    3.当static修饰成员方法时,该方法被称为类方法。也习惯称为静态方法。
          定义格式:
                            修饰符  static 返回值类型 方法名(参数列表) {
                    //方法体内容
                    .....
            } 
      类方法调用时细节:
            1.静态方法可以直接访问类变量和类方法
            2.静态方法不能直接访问普通的成员方法和成员变量。反之,成员方法可以直接访问类变量和类方法。
            3.静态方法中,不能使用this关键字和super关键字。      
            4.被static修饰的方法,建议通过类名直接调用,也可以通过对象名来调用,但是程序出现警告信息。    
 */
public class StaticDemo extends Employee{

    static String name = "小刘";
    
    public void eat() {
        System.out.println("我在美美的吃大餐。。。");
    }
    
    public static void main(String[] args) {
        //super.work();
        //this.eat();
        StaticDemo  s1 = new StaticDemo();
        s1.name = "小王";
        System.out.println("s1的name值为:"+s1.name);// 小王
        StaticDemo  s2 = new StaticDemo();
        System.out.println("s2的name值为:"+s2.name);// 小刘
        StaticDemo  s3 = new StaticDemo();
        System.out.println("s3的name值为:"+s3.name);// 小刘
        StaticDemo  s4 = new StaticDemo();
        System.out.println("s4的name值为:"+s4.name);// 小刘
        
        
    }

Permissions

package buli.Extends;

public class PermissionsDemo {

    
    /* 权限修饰符
     * 
     * public protected 不写(默认的) private
     * 
     * 访问范围:
     *         当前类中
     *      同包下不同类中
     *      不同包无关类
     *      不同包的子类
     */
    
    
    
}

Managers

package buli.Extends;

public class Managers {

    double salary;
}

Employee

package com.zhiyou100.Extends;

// 员工类  父类
public class Employee extends Human{
     //成员变量
     String name = "小刘";
     private int age;
     
     //成员方法
     protected void work() {
         System.out.println("尽心尽力的工作。。");
     }
    
}

Final

package buli.Extends;

/*
 *   final关键字: 最终的,最后的
 *       特点:
 *           1.当final关键字修饰类的时候,这个类不能被继承,但是不影响对象的创建如String类
 *          2.当final关键字修饰方法的时候,这个方法不能被重写,但是父类中的没有被final修饰的
 *            方法,子类覆盖后可以添加final关键字。
 *          3.静态的方法重写后一般只能是静态的,非静态的方法重写后一般只能非静态的。
 *          4.final修饰局部变量,只能够赋值一次。当修饰的是引用的类型的时候,不能被重新赋值
 *            但是可以修改对象的属性
 *            全局变量是声明在类内部方法外部。
 *            局部变量一般声明方法内或者代码块中。
 *          5.final修饰成员变量,必须在定义的时候进行赋值,不会有自动初始化值(在构造方法中进行赋值)
 */
public class FinalDemo {
    
    final String name;
    
    public FinalDemo() {
        name = "李四";
    }
    
    public static void work() {
        
        System.out.println("我在上课。。。");
    }
    String[] args;
    /*{
        String[] args;
        if (1== 2) {
            String[] args;
        }
        
    }*/
    public static void main(String[] args) {
        final String name;
        final int[] arr = {10,20,30};
        arr[0] = 50;
        final int age = 18;
        //String[] args;
        if (1 != 2) {
            //String[] args;
        }
        //name = "李四";
        //age = 20;
        
    }

}
class Zi extends FinalDemo{
    
    public  static void work() {
        
        System.out.println("我在吃饭。。。");
    }
    
    
}

 

上一篇:day17-面向对象作业


下一篇:基于深度学习的语义分割