Java提升学习（二）：构造方法，类的继承，封装

一、构造方法

类有一种特殊的成员方法叫做构造方法，构造方法与类同名，在创建对象时，会自动调用类的构造方法。
构造方法没有返回类型，更不能定义为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)
如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (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代码很是优雅，高效。

学习笔记图片摘自“黑马程序员”

Java提升学习（二）：构造方法，类的继承，封装

Java提升学习（二）：构造方法，类的继承，封装

猜你喜欢