关于java:Java2基本特性2

Java 个性.xmind

封装是指暗藏对象的属性和细节，但对外提供公共的拜访形式
办法
1. 办法重载（办法名称雷同，参数项不雷同，重载只跟参数无关，与返回类型无关）

留神：

        应用重载办法时，记住这两条重要的规定：不能仅通过更改一个办法的返回类型来重载该办法。不能有两个名称和参数列表都雷同的办法

构造方法重载
this 关键字（代表对象，this 就是所在函数的所属对象的援用）
- 当成员变量和局部变量重名，能够用关键字 this 来辨别
- this 也能够用于在构造函数中调用其它构造函数。（this 只能定义在构造函数的第一行，因为初始化动作必须要先执行）

封装劣势
- 良好的封装可能缩小耦合
- 类外部的构造能够自在批改
- 能够对成员变量进行更准确的管制
- 暗藏信息，实现细节
代码

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 + "岁。");
    }
}

继承能够被定义为一个对象获取另一个对象属性的过程
办法（办法覆写）

子类的办法的名称、参数签名和返回类型必须与父类的办法的名称、参数签名和返回类型统一
子类办法不能放大父类的拜访权限
子类办法不能抛出比父类更多的异样
办法笼罩只存在于子类和父类（包含间接父类和间接父类）之间
父类的静态方法不能被子类笼罩为非静态方法
子类能够定义与父类的静态方法同名的静态方法，以便在子类中暗藏父类的静态方法
父类的非静态方法不能被子类笼罩为静态方法
父类的公有办法不能被子类笼罩
父类的形象办法能够被子类通过两种路径笼罩：一是子类实现父类的形象办法；二是子类从新申明父类的形象办法（例如，扩充拜访权限）
父类的非形象办法能够被笼罩为形象办法

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;}


}

继承父类的子类的能够做什么
- 子类的构造方法与父类的构造方法关系
  - 子类是不继承父类的结构器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的结构器带有参数，则必须在子类的结构器中显式地通过 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); 
  }
}

子类办法与父类办法关系
- 实例办法
- 静态方法

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

向上类型转换（upcast）：
比如说将 Cat 类型转换为 Animal 类型，行将子类型转换为父类型
向下类型转换（downcast）：
比方将 Animal 类型转换为 Cat 类型

长处：
- 打消类型之间的耦合关系
- 可替换性
- 可扩充性
- 接口性
- 灵活性
代码

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();}
}

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

参考资料：

https://dev.java/learn/
https://www.runoob.com/java/java-encapsulation.html

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

关于java:Java2基本特性2

一、思维导图

二、知识点及实际

1、Java 根本个性

1.1、封装

1.2、继承

1.3、多态

1.4、形象

三、相干扩大