Java中方法与属性定义与调用（static,final,构造方法）

Java中的调用分为属性调用和方法调用，如果想要能够进行调用需要满足两个条件：访问控制符，类是否存在该属性和方法。以下主要讨论前提是所有属性和方法都是public访问修饰符下的调用情况

方法签名：方法名称和方法的参数列表构成了方法的签名（thinking of  java中定义的）

1. 子类接受所有父类的方法和属性（构造方法，子类不能够直接调用，父类也不能够直接调用）
2. 子类定义方法和属性的情况
   1. 子类定义方法
      1. 方法的分类有抽象方法，普通方法，静态方法，构造方法，final方法
      2. 抽象方法：
         1. 存在抽象方法的类为抽象类或者接口，jdk1.8以后接口中可以存在默认的方法
         2. 抽象类不可实例化
      3. 普通实例方法
         1. 实例方法可以调用且满足重载和重写
      4. 静态方法
         1. 它是类方法
         2. 子类可以进行调用
         3. 子类，和父类不可以声明相同方法签名的实例方法
         4. 子类可以相同方法前面的静态方法，但是这不是重写。而仅仅是重新定义。
         5. static可以继承不可以重写
      5. 构造方法
         1. 不可以进行显示调用（暂时没有发现）
         2. 父类和子类可以重新定义相同方法签名的静态方法，实例方法
      6. final方法
         1. 子类可以进行调用
         2. 子类不能定义相同方法签名的方法
   2. 子类定义属性
      1. 属性没有重写，重载的概念
      2. 子类属性可以调用父类可见的属性
      3. 子类可以声明和父类相同名的属性
         1. 注意点：当new一个子类对象后，子类调用子类的属性值。当子类强制转化为父类时再次调用属性则是父类的属性值

验证代码如下

//父类代码
package staticTest;

/*
 * 测试相关事件
 * 调用问题：
 * 方法
 * 	抽象方法
 *  普通方法
 *  构造方法
 *  静态方法
 *  	静态方法和非静态方法不能够有相同方法签名
 *  final方法 
 *  	
 * 属性
 *    普通属性
 *    静态属性
 *    常量
 * 重写问题：
 * 	 重写是子类中重新定义父类的方法，不管对象如何转化被重写的方法都是子类重新定义的方法叫做重写
 * 重载问题：
 * 	在一个类内部初始化多个方法名相同，方法签名不同的方法叫做重载
 * 
*/public class Father {

	public   int i;
	
	public static int istatic=2;
	
	public final  int ifinal;  
	
	public Father() {
		this.i=2;
		this.ifinal=2;
	}
	public Father(int i) {
		this.i=1;
		this.ifinal=2;
	}
	//我是和父类相同方法签名的普通方法
	public void Father() {
		System.out.println("这是一个父类的Father方法,但不是构造方法");
	}
	
	public static void  fatherStatic() {
		System.out.println("这是一个父类的static方法");
	}
	//静态方法和非静态方法不可用相同的方法签名
//	public  void  fatherStatic() {
//		System.out.println("这是一个父类的static方法");
//	}
	//
	//静态方法和非静态方法不可用相同的方法签名
	public  void  fatherStatic(int i) {
		System.out.println("这是一个父类的static方法");
	}
	
	/**
	 *fatherFinal使用
	 */
	public final static void fatherFinal() {
		System.out.println("这是父类的final方法");
	}
	//方法不能够定义
//	public void fatherFinal() {
//		System.out.println("这是父类的final方法");
//	}
	
	//private
	private void fatherPrivate() {
		System.out.println("这是父类的私有方法");
	}
}

//子类代码

package staticTest;
//子类
public class Son extends Father {
    
//	public int i=3;
//	
//	public final int ifinal=3;
//
//	public static int istatic=3;
	
	public  static void parentStatic() {
		System.out.println("这是个子类的静态方法");
	}
	//静态方法相关
	//父类的静态方法
	public static void  fatherStatic() {
		System.out.println("这是一个子类的static方法");
	}
	//当父类存在静态方法时，子类中不允许相同方法签名的普通方法
//	public  void  fatherStatic() {
//		System.out.println("这是一个子类的static方法");
//	}
	//重新定义父类构造方法
	public void Father() {
		
	};
	//abstract当子类定义抽象方法子类型必须为抽象类或者接口
//	public abstract void sonAbstract();
	
	//Final
	//当父类存在final方法时，
	//			则子类不可以定义相同方法签名的
	//
//	public final void fatherFinal() {
//		System.out.println("这是子类的final方法");
//	}
//	public void fatherFinal() {
//		System.out.println("这是子类的final方法");
//	}
//	public static void fatherFinal() {
//		System.out.println("这是子类的final方法");
//	}
	//以下定义可以使用
	public final void fatherFinal(int i) {
		System.out.println("这是父类的final方法");
	}
	
	
}

//测试代码

package staticTest;

public class TestOverride {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//关于静态方法
		//当父类定义了静态方法时
		//  静态方法只能调用静态方法，不能够直接调用普通方法
		//  父类和子类中不允许生成方法签名的实例方法,eclipse会编译器报错
		//	静态方法和非静态方法个人以为不构成重载，静态方法属于类。只能和静态方法构成重载。
		//  						非静态方法属于对象智能和非静态方法构成重载。
		//	子类通过继承可以直接访问父类的静态方法
		//  子类可以定义和父类相同方法签名的静态方法，相当于将父类的静态方法进行隐藏，非重写。不具有多态性质
		//  静态方法不能被覆盖，就是不能被重写
		Son son=new Son();
		//调用子类的静态方法
		son.fatherStatic();
		Father father=(Father)son;
		//调用父类的静态方法
		father.fatherStatic();
		
		//父类中定义了普通实例方法,子类可以进行继承 ，重写和重载符合多态特性
		//在此不再演示
		
		//构造方法
		//子方法可以定义相同名称的构造方法，但它不是重写.它只是个重新定义
		son.Father();
		//父类的构造方法不能直接调用
//		father.Father();
		
		//final修改的方法
		//当父类存在final修饰的方法时，则这个方法能被子类进行继承调用
		//					子类和父类中不能存在相同签名的实例方法
		//					子类中定义相同的方法签名的方法则编译不通过
		son.fatherFinal();
		
		//属性
		//不管静态属性，final属性，普通属性
		//他们都可以被子类进行继承，当子类不进行定义时，则可以调用父类的属性值
		//		当用户定义了同名属性，则子类进行使用则会使用自己的值，并且当子类对象转化为父类对象，则值变成父类中定义的值
		//		综上所述，属性不存在重载和重写的概念
		int s=son.i;
		int i=father.i;
		System.out.println("当前获取的变量是（3.代表子类的int，2代表父类int）"+s+"==="+i);
		int sStatic=son.istatic;
		int iStatic=father.istatic;
		System.out.println("当前获取的变量是（3.代表子类的static int，2代表父类static int）"+sStatic+"==="+iStatic);
		int sfinal=son.ifinal;
		int ifinal=father.ifinal;
		System.out.println("当前获取的变量是（3.代表子类的final int，2代表父类final int）"+sfinal+"==="+ifinal);
		

	}
}