一、思维导图
Java个性.xmind
二、知识点及实际
1、Java根本个性
1.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 + "岁。"); }}1.2、 继承
- 继承能够被定义为一个对象获取另一个对象属性的过程
- 办法（办法覆写）
- 子类的办法的名称、参数签名和返回类型必须与父类的办法的名称、参数签名和返回类型统一
- 子类办法不能放大父类的拜访权限
- 子类办法不能抛出比父类更多的异样
- 办法笼罩只存在于子类和父类（包含间接父类和间接父类）之间
- 父类的静态方法不能被子类笼罩为非静态方法
- 子类能够定义与父类的静态方法同名的静态方法，以便在子类中暗藏父类的静态方法
- 父类的非静态方法不能被子类笼罩为静态方法
- 父类的公有办法不能被子类笼罩
- 父类的形象办法能够被子类通过两种路径笼罩：一是子类实现父类的形象办法；二是子类从新申明父类的形象办法（例如，扩充拜访权限）
- 父类的非形象办法能够被笼罩为形象办法
- 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); }}子类办法与父类办法关系
- 实例办法
- 静态方法
1.3、 多态
- 多态性是指对象可能有多种状态。多态就是同一个接口，应用不同的实例而执行不同操作
- 必要三个条件：继承、重写、父类援用指向子类对象：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(); }}1.4、 形象
- 抽象类,有形象办法的类就叫抽象类
- 形象办法:在类中没有办法体的办法，就是形象办法
- 接口与抽象类之间不同及如何抉择
三、相干扩大
- 参考资料：
- https://dev.java/learn/
https://www.runoob.com/java/java-encapsulation.html
本文由博客一文多发平台 OpenWrite 公布！