乐趣区

关于java:Java2基本特性2

一、思维导图

Java 个性.xmind

二、知识点及实际

1、Java 根本个性

1.1、封装

  1. 封装是指暗藏对象的属性和细节,但对外提供公共的拜访形式
  2. 办法

    1. 办法重载(办法名称雷同,参数项不雷同,重载只跟参数无关,与返回类型无关)

留神:

        应用重载办法时,记住这两条重要的规定:不能仅通过更改一个办法的返回类型来重载该办法。不能有两个名称和参数列表都雷同的办法
  • 构造方法重载
  • this 关键字(代表对象,this 就是所在函数的所属对象的援用)

    • 当成员变量和局部变量重名,能够用关键字 this 来辨别
    • this 也能够用于在构造函数中调用其它构造函数。(this 只能定义在构造函数的第一行,因为初始化动作必须要先执行)
  1. 封装劣势

    • 良好的封装可能缩小耦合
    • 类外部的构造能够自在批改
    • 能够对成员变量进行更准确的管制
    • 暗藏信息,实现细节
  2. 代码
public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 构造函数、getter 和 setter 办法
    public String getName() {return name;}

    public void setName(String name) {this.name = name;}

    public int getAge() {return age;}

    public void setAge(int age) {this.age = age;}

    // 其余办法,比方一个简略的打招呼办法
    public void sayHello() {System.out.println("你好,我是" + name + ",往年" + age + "岁。");
    }
}

1.2、继承

  1. 继承能够被定义为一个对象获取另一个对象属性的过程
  2. 办法(办法覆写)
  • 子类的办法的名称、参数签名和返回类型必须与父类的办法的名称、参数签名和返回类型统一
  • 子类办法不能放大父类的拜访权限
  • 子类办法不能抛出比父类更多的异样
  • 办法笼罩只存在于子类和父类(包含间接父类和间接父类)之间
  • 父类的静态方法不能被子类笼罩为非静态方法
  • 子类能够定义与父类的静态方法同名的静态方法,以便在子类中暗藏父类的静态方法
  • 父类的非静态方法不能被子类笼罩为静态方法
  • 父类的公有办法不能被子类笼罩
  • 父类的形象办法能够被子类通过两种路径笼罩:一是子类实现父类的形象办法;二是子类从新申明父类的形象办法(例如,扩充拜访权限)
  • 父类的非形象办法能够被笼罩为形象办法
  1. super 关键字

拜访成员变量:super. 成员变量
拜访构造方法:super(……)
拜访成员办法:super. 成员办法()

public class Bicycle {

    // the Bicycle class has
    // three fields
    public int cadence;
    public int gear;
    public int speed;

    // the Bicycle class has
    // one constructor
    public Bicycle(int startCadence, int startSpeed, int startGear) {
        gear = startGear;
        cadence = startCadence;
        speed = startSpeed;
    }

    // the Bicycle class has
    // four methods
    public void setCadence(int newValue) {cadence = newValue;}

    public void setGear(int newValue) {gear = newValue;}

    public void applyBrake(int decrement) {speed -= decrement;}

    public void speedUp(int increment) {speed += increment;}

    public void printDescription(){
        System.out.println("\nBike is" + "in gear" + this.gear
                + "with a cadence of" + this.cadence +
                "and travelling at a speed of" + this.speed + ".");
    }

}



public class MountainBike extends Bicycle {public MountainBike(int startCadence, int startSpeed, int startGear) {
        // 调用父类的构造方法
        super(startCadence, startSpeed, startGear);
        // MountainBike 特有的初始化代码
        seatHeight = 0;
    }

    private int seatHeight;

    public void setSeatHeight(int newSeatHeight) {this.seatHeight = newSeatHeight;}


    public int bikeSum(int a, int b) {return a + b;}


}
  1. 继承父类的子类的能够做什么

    • 子类的构造方法与父类的构造方法关系

      • 子类是不继承父类的结构器(构造方法或者构造函数)的,它只是调用(隐式或显式)。如果父类的结构器带有参数,则必须在子类的结构器中显式地通过 super 关键字调用父类的结构器并配以适当的参数列表。如果父类结构器没有参数,则在子类的结构器中不须要应用 super 关键字调用父类结构器,零碎会主动调用父类的无参结构器
class SuperClass {
  private int n;
  SuperClass(){System.out.println("SuperClass()");
  }
  SuperClass(int n) {System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 主动调用父类的无参数结构器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){super(300);  // 调用父类中带有参数的结构器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){super(300);  // 调用父类中带有参数的结构器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 主动调用父类的无参数结构器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{public static void main (String args[]){System.out.println("------SubClass 类继承 ------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承 ------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}
  • 子类办法与父类办法关系

    • 实例办法
    • 静态方法

1.3、多态

  1. 多态性是指对象可能有多种状态。多态就是同一个接口,应用不同的实例而执行不同操作
  2. 必要三个条件:继承、重写、父类援用指向子类对象:Parent p = new Child()
  3. 转型

向上类型转换(upcast):
比如说将 Cat 类型转换为 Animal 类型,行将子类型转换为父类型
向下类型转换(downcast):
比方将 Animal 类型转换为 Cat 类型

  1. 长处:

    • 打消类型之间的耦合关系
    • 可替换性
    • 可扩充性
    • 接口性
    • 灵活性
  2. 代码
public class MountainBike extends Bicycle {
    private String suspension;

    public MountainBike(int startCadence, int startSpeed, int startGear, String suspension) {super(startCadence, startSpeed, startGear);
        this.suspension = suspension;
    }

    public String getSuspension() {return this.suspension;}

    public void setSuspension(String suspensionType) {this.suspension = suspensionType;}

    public void printDescription() {super.printDescription();
        System.out.println("The" + "MountainBike has a" +
                getSuspension() + "suspension.");
    }
}



public class RoadBike extends Bicycle {
    // In millimeters (mm
    // )
    //  This is a property specific to a RoadBike.
    private int tireWidth;

    public RoadBike(int startCadence,
                    int startSpeed,
                    int startGear,
                    int newTireWidth){
        super(startCadence,
                startSpeed,
                startGear);
        this.setTireWidth(newTireWidth);
    }

    public int getTireWidth(){return this.tireWidth;}

    public void setTireWidth(int newTireWidth){this.tireWidth = newTireWidth;}

    public void printDescription(){super.printDescription();
        System.out.println("The RoadBike" + "has" + getTireWidth() +
                "MM tires.");
    }
}



public class TestBikes {public static void main(String[] args) {
        Bicycle bicycle1 , bicycle2
                , bicycle3;

        bicycle1 = new Bicycle(20,10,1);
        bicycle2 = new MountainBike(20,10,1,"moutain");
        bicycle3 = new RoadBike(20,10,1,11);
        bicycle1.printDescription();
        bicycle2.printDescription();
        bicycle3.printDescription();}
}

1.4、形象

  1. 抽象类, 有形象办法的类就叫抽象类
  2. 形象办法: 在类中没有办法体的办法,就是形象办法
  3. 接口与抽象类之间不同及如何抉择

三、相干扩大

  1. 参考资料:
  • https://dev.java/learn/
  • https://www.runoob.com/java/java-encapsulation.html

    本文由博客一文多发平台 OpenWrite 公布!

退出移动版