Java提升学习（二）：构造方法，类的继承，封装
Java提升学习（二）：构造方法，类的继承，封装
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效 果，也称为重写或者复写。声明不变，重新实现。
作者：繁星和孤岛的故事
一、构造方法
类有一种特殊的成员方法叫做构造方法，构造方法与类同名，在创建对象时，会自动调用类的构造方法。
构造方法没有返回类型，更不能定义为void，不可加其他修饰符。
若没有被定义，则在编译的时候，会自动加上一个默认的构造方法，但是不会有任何操作。
可重载多个构造方法。
示例：
修饰符 构造方法名(参数列表){
// 方法体
}
public class second {
private String name;
private int age;
//public second() {}; //无入参构造方法
public second() {//默认值
name = "haha";
age = 20;
}
public second(String _name,int _age){//有入参的构造方法
name = _name;
age = _age;
}
public String getname() {
return name;
}
}
public class first {
public static void main(String[] args) {
second a = new second();
second b = new second("xixi",21);
System.out.println("此时a:" + a.getname());
System.out.println("此时b:" + b.getname());//已封装，通过方法访问
}
}
//------------输出--------------
此时a:haha
此时b:xixi
可见，不带入参的构造方法在被编辑的时候，输出的仍然是默认值。值得注意的是： 我们在new一个对象的时候，就是再调用构造方法。
Java Bean——标准类代码JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无/参数的构造方法，提供用来操作成员变量的 set 和 get 方法。
示例：
public class ClassName{
//成员变量
//构造方法
//无参构造方法【必须】
//有参构造方法【建议】
//成员方法
//getXxx()
//setXxx()
}
public class Student {
//成员变量
private String name;
private int age;
//构造方法
public Student() {}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
//成员方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
二、类的继承
继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。
多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类，继承描述的是事物之间的所属关系。
提高代码的复用性。 类与类之间产生了关系，是多态的前提。
继承的格式：通过关键字extends来使得类被继承。
public class father{
//...
}
public class son extends father{
//...
}
咱们用标准化Java语言来写一下：
public class second {
//成员变量
private String name;
private int age;
//构造方法
public second() {}
public second(String name,int age) {
this.name = name;
this.age = age;
}
//成员方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void method() {//方法
System.out.println("hahahahahaha");
}
}
继承：
public class first extends second{
public static void main(String[] args) {
second a = new second("woaini",20);
System.out.println(a.getAge() + a.getName());
a.method();
}
}
//-----------输出-----------
20woaini
hahahahahaha
当然，这里只是一个继承类，如果有多个子类，那么继承的优点“复用性”
重名变量名：如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。class Fu {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num2 = 6;
// Zi中的成员方法
public void show() {
// 访问父类中的num，
System.out.println("Fu num="+num); // 继承而来，所以直接访问。
// 访问子类中的num2
System.out.println("Zi num2="+num2);
}
}
class ExtendDemo02 {
public static void main(String[] args) {
// 创建子类对象
Zi z = new Zi();
// 调用子类中的show方法
z.show();
}
}
//----------输出---------------
Fu num = 5
Zi num2 = 6
但是如果重名的话，这时的访问是有影响的。
class Fu {
// Fu中的成员变量。
int num = 5;
}
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
// 访问父类中的num
System.out.println("Fu num=" + num);
// 访问子类中的num
System.out.println("Zi num=" + num);
}
}
class ExtendsDemo03 {
public static void main(String[] args) {
// 创建子类对象
Zi z = new Zi();
// 调用子类中的show方法
z.show();
}
}
//-----------输出-----------
Fu num = 6
Zi num = 6
子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于 this 。
使用格式：
super.父类成员变量名；，
this.此类成员变量名；（this代表所在类的当前对象的引用（地址值），即对象自己的引用。
）
class Zi extends Fu {
// Zi中的成员变量
int num = 6;
public void show() {
//访问父类中的num
System.out.println("Fu num=" + super.num);
//访问子类中的num
System.out.println("Zi num=" + this.num);
}
}
//--------输出-------------
Fu num = 5
Zi num = 6
this的用法：
public class Student {
private String name;
private int age;
public void setName(String name) {
//name = name;
this.name = name;
}
}
总结一下super的使用方法：
总结一下this的使用方法：
内存图如下：
可发现，在内存中是个栈，实现逐步调用。在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员。
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效 果，也称为重写或者复写。声明不变，重新实现。
class Fu {
public void show() {
System.out.println("Fu show");
}
}
class Zi extends Fu {
//子类重写了父类的show方法
public void show() {
System.out.println("Zi show");
}
}
public class ExtendsDemo05{
public static void main(String[] args) {
Zi z = new Zi();
// 子类中有show方法，只执行重写后的show方法
z.show(); // Zi show
}
}
三、Java继承的三个特点
四、封装
面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。 封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的 方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。
private 关键字来修饰成员变量。对需要访问的成员变量，提供对应的一对 get（） 方法 、 set（）方法。
private使用格式：private 数据类型 数据名；
示例:
public class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
}
可用this关键字，和构造方法来优化封装性，如果想写一个好的代码，JavaBean代码很是优雅，高效。
学习笔记图片摘自“黑马程序员”
作者：繁星和孤岛的故事
