这是我第一次写博客，进入Android这个大坑已经有一段时间了，在学习Java过程中，把学习记录下来的笔记进行一个总结，觉得以博客的形式进行输出，从而更加巩固自己对知识的掌握程度。

方法主要区别在三个方面：修饰符、返回值、命名

方法中的参数分为： - 实际参数：实际参与运算的 - 形式参数：方法定义上的，接受实际参数的

方法大概分为一下九种：

一般方法
构造方法
无返回值的方法。
无参有返回值的方法。
有参无返回值的方法。
有参有返回值的方法。
静态方法。
非静态方法。
抽象方法。

其中还有

方法的重载
方法的重写
方法的调用

其中用到的修饰符

方法如下

int a = 1；
//一般方法
public Sample() { 
    System.out.println(a); 
} 

public void Sample() { // 无返回值的方法，void就是空的意思
    System.out.println(a); 
}  

public int Sample() { //无参有返回值的方法
    System.out.println(a); 
    return a; 
}  
public void Sample(int a) { // 有参无返回值的方法
    System.out.println(a); 
} 

public int Sample(int a) { // 有参有返回值的方法
    System.out.println(a); 
    return a;
}
public static void Sample() { // 静态方法。
    System.out.println(a); 
}  
public void Sample() { // 非静态方法。
    System.out.println(a); 
}  
public void Sample() { // 非静态方法。
    System.out.println(a); 
}  

public abstract void Sample() { // 抽象方法，abstract不能与private、static、final、native并列修饰同一个方法。
    System.out.println(a); 
}

方法的重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

public class Overloading {
 public int test(){
    System.out.println("test1");
    return 1;
}

 public void test(int a){
    System.out.println("test2");
}   

//以下两个参数类型顺序不同
    public String test(int a,String s){
     System.out.println("test3");
     return "returntest3";
}   

    public String test(String s,int a){
     System.out.println("test4");
        return "returntest4";
}   

    public static void main(String[] args){
     Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

方法的重写

参数列表必须完全与被重写方法的相同；返回类型必须完全与被重写方法的返回类型相同；访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。父类的成员方法只能被它的子类重写。声明为final的方法不能被重写。声明为static的方法不能被重写，但是能够被再次声明。子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。构造方法不能被重写。如果不能继承一个方法，则不能重写这个方法。

当需要在子类中调用父类的被重写方法时，要使用super关键字。代码如下：

class Animal{
   public void move(){
  System.out.println("动物可以移动");
   }
}

class Dog extends Animal{
   public void move(){
  super.move(); // 应用super类的方法
  System.out.println("狗可以跑和走");
   }
}

public class TestDog{
   public static void main(String args[]){

  Animal b = new Dog(); // Dog 对象
  b.move(); //执行 Dog类的方法

   }
}

运行结果：

动物可以移动

狗可以跑和走

下面图片区分重写(Overriding)和重载(Overloading)的区别

方法的调用

public class InvokeMethod{ 
    public static void main (String[] args){ 
        InvokeMethod.t2(); 
} 
    public static void t2(){ 
        System.out.println("static t2....");
    } 
}

感谢浏览到最后，努力的小人儿运气不会差。

Java基础回顾——方法