Java 类的方法总结（目前网上最完整10种方法总结梳理）

定义一个完整的类方法，需要六个步骤，也就是六大部分。也因为这六个部分的不同而可以大概分为9种方法。
这是我一整天作图整理出来的。可能有些漏缺错误，希望大家能帮忙纠正。让我明白哪里错了，这是对我这个初学者最大的帮助，谢谢。

一，一般方法
二，构造方法
三，无参无返回值的方法。
四，无参有返回值的方法。
五，有参无返回值的方法。
六，有参有返回值的方法。
七，静态方法。
八，非静态方法。
九，抽象方法。
另外在加上
方法的重载
方法的重写。
方法的调用。
可能是目前关于java 方法最完整的总结了。当然还有例如有参的构造方法等一些组合，就没必要一一列举了。后面会有些许介绍，后期再继续编辑优化。

第一步，访问修饰符。参考前面写的成员变量与局部变量。就不罗嗦了。

第二步，关键词。
关键词主要有static和abstract两个关键词。
有static修饰的方法叫做静态方法。没有的则叫非静态方法。
其中我们最熟悉的main方法就有static 修饰。这个方法也是我最不熟悉搞不懂的方法。

static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的。因为它不依附于任何对象，既然都没有对象，就谈不上this了。
1.其实可以理解为此类所共有的方法。我理解的就是类方法。所以可以直接用类名调用。至于为何有这种麻烦的静态方法以及静态变量的存在，我认为有两个原因。
第一，
静态变量/方法只需要初始化一次，而不像其他的每调用一次就要初始化一次。可以减少内存空间的使用。
静态的可以被直接访问而不实例化自身再访问，大型程序考虑内存占用问题 超小程序直接静态化，更加方便些。

第二，不知道大家注意到main方法以及后面类与对象没有。
在后面一大堆父子类。都是没有main方法的。更不会有一大堆的静态方法，静态方法常驻内存，会大量消耗内存空间。
所以基本上只有一个测试类有main方法以及static修饰的。这样的方法可以直接测试。如果你没有必要去访问对象的外部，那么就使你的方法成为静态方法。她会被更快地调用。
这些算是程序的优化吧。
实在没有找到比慕.课.网更好更方便的图片了。就用这个了。

2. 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。
至于原因我感觉还是因为内存原理。非静态方法/变量只有实例化之后才被放进堆内存，此前在栈内存，而静态方法与变量则在栈内存。不在一个内存区，所以无法直接调用。也不知道对不对。希望不会误导大家。

3. 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。原理如上，实例如下：

4.
并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。

另一个关键字。Abstract。被他修饰的方法叫做抽象方法。
抽象方法：在类中没有方法体的方法，就是抽象方法。

抽象方法必须被实现！也就是被继承。所以他所在的类必然是父类。一定有一个子类。

如果一个子类没有实现父类中的抽象方法，则子类也成为了一个抽象类！

抽象方法必须被重写。从没有方法体变为有具体的方法体。

抽象类不能被实例化。也就是只能继承，不能new。这是很少见的。因为new基本上畅通无阻。到了抽象方法这就停了。

抽象方法只需声明，而不需实现某些功能。就好像大蒙古国的海军一样。只需要有名头，不需要有舰队。

第三步，返回值有否？
如果有返回值就是有返回值方法。
有返回值，则写具体返回类型，比如string int 等返回的类型，这就是java强类型的一个表现。

而且方法体里面要有return 符合返回类型的变量名。内外一致。而且只能返回一个数据。
如果是多个数据的话，还是多种类型的数据的话，第一拆分这个方法成为更加简单的精简方法。第二就是用数组来接受这些数据。

为何有反回类型的方法呢，因为他返回的数据将要被被其他方法采用，甚至多次采用。加工处理。所以就需要这个数据，他不是最终的输出结果。所以要有返回类型，而且必须用变量来进行接受，然后传递给其他方法进行处理。

没有就是无返回值方法。用void修饰。
因为这是最终的处理结果。所以无需再接受处理，直接用println输出就行。这样的结果不能再被println再次输出，不然就会报错。

返回类型与无返回值类型的方法的使用

public String display(){
String aa="影片名字:"+name+"\n类型:"+type+"\n导演:"+daoyan+"\n主演:"+zhuyan;
return aa;}
/*反回string类型aa。方法名前面必须添加想要返回的类型。这种方法有些限制。比如一次只能返回一种类型。不可能在string 后面加一个int，或者再加一个其他类型。/
下面的一句就是创建的对象中调用的方法。
System.out.println(f.display());
}
public void display1(){
System.out.println("影片名字:"+name+"\n类型:"+type+"\n导演:"+daoyan);
}
//方法名前面的void就意味着没有返回值，也就不用设置返回的类型。下面一句是就是创建的对象中调用的方法：
f.display1();

前面带有返回类型的方法只有返回数据，而没有输出数据，所以调用的时候还必须添加输出的方法。后面没有返回类型的方法已经封装了输出的方法，所以创建对象的时候直接调用方法就行。而不能在加上System.out.println(f.display1());输出方法再套一个输出方法。

第四步。方法的名称。

为了见名知意，也就是可以自定义。尽量有意义，第一样就明白是什么意思，代表了什么，而且尽量用英文，如果是词组的话，第二个单词首字母大写。

既然可以自定义，就有了一个特殊的方法名。与类名相同的方法——构造方法。

构造方法的作用就在于一下子可以一下子调用多个属性，还省了一一赋值的麻烦，避免了缺漏。对于大型方法非常实用。同样因为一次性调用多个属性，必然参数很多。但是连void也没有。

当然系统还有一个默认的隐藏的无参构造方法。也就是说每一个类中必然有一个无参构造方法。只不过平常隐藏起来了。一旦出现有参的构造方法，就必须将无参的构造方法也写出来。

构造方法虽然可以和其他方法组合，但是不能被static、final、synchronized、abstract和native修饰。我也不知道这个的意义所在。

当然官方定义说构造方法的主要作用是数据的初始化。我的理解是，既然要被调用，公有的属性肯定不可能事先赋值，要到子类实例化才能赋值，而只能一一调用，一一赋值，这样很容易缺漏。而构造方法能在直接new 类名（具体参数）。方便快捷。

通过类创建一个对象。如果类比较庞大，属性比较多，方法比较多。记忆就会比较困难，很容易落下什么。而且一个个调用属性和方法很麻烦，能不能一下子全部调用过来。省的拉下了。这就是构造方法带来的好处。

既然是调用的整个类的属性与方法，那么方法名就与类名保持一致。
而且因为属性多种多样。有int类型，有string类型。这样你就无法确定返回值是哪个类型，干脆就不定义返回类型。

根据参数的有无可以分为有参方法与无参方法，同样可以喝返回值方法自由组合，构成有无参数有无返回值类型的方法。当然还有其他的组合。

而且因为需要的参数不同，类型不同，所以构造方法的参数类型就会不同，以适应不同的需要。这样一来诸多同名的构造方法就构成了方法的重载。刻意这样理解，重复加载，只不过加载的不一样而已。这之间最大的区别就是参数列表。

也就是下一步。

第五步，参数列表。

为何要有参数。因为现实是多姿多彩的，需要很多的形容词来修饰，而在编程中就需要很多的变量来修饰。比如：

public void sleep(){
System.out.println("我在睡觉");
}
需要一个变量来修饰睡觉，于是用一个参数。实际上就是定义一个变量类型。

public void sleep(String i){
System.out.println("我在"+i+"睡觉");
}
需要两个变量，于是用两个参数。实际上就是定义两个变量类型。

public void sleep(String i,int j){
System.out.println("我在"+i+"睡觉"+j+"点起来")

有时需要更多的修饰，于是就有了更多的参数。这就是参数的存在意义。

当然有人会问：直接调用属性就行，干嘛用参数，还要形参，实参，传参。很是麻烦。比如：
string name；int time；
public void sleep(){
System.out.println(name+"在睡觉"+time+"点起来")

这样理解，父类中肯定不会有属性的具体值。子类中可能有某些属性的具体属性赋值，所以就必然要将某些属性从子类传递给父类。用get/set方法可行，不过有些慢，所以就出现了专门的属性值传递的通道。

那就是传递参数，传参。这根前面属性值赋值一回事，只不过从面向过程的一个类中赋值，变为了多个类之间相互赋值。如此就变成了类之间的传递参数。

既然有了传递参参。就必然有参与传递的双方，一方就是传递者，传递了具体的参数，就是实参，一方是接受者，随时准备接受，但是随时可能没有参数，于是叫做形式参数，形参。

所以参数列表可以说是类之间属性赋值的一个专门通道。是面向对象思路的必然。

第六步。方法体。

主要的区别就在于有无。也就是有具体的方法体以及没有方法体。甚至都可以没有大括号。小括号就能组成一个方法。
最简单的方法就是方法名（）；

接下来就是方法重载，方法重写，方法调用了。

方法重载：

从构造方法里面我们发现了方法的重载，方法名相同， 形参不同。

而形参的不同又表示在：  1）. 形参的个数不同  2）. 形参的类型不同 3）. 形参的顺序不同。

其实在调用Scanner的时候很类似，或者就是方法的重载。Input.next()。这后面可以跟不同的数据类型。

与此类似jdk帮助文档的每一个方法有很多方法名相同，但是因为数据类型不同而生出区别的不同方法，这些只是因为调用接受设置的收据类型不同而成为同名的方法重载。如果一一为这些方法重命名，不仅我们要崩溃，设计者首先就会崩溃。这也跟java是强类型语言有直接关系。

从这里我们也可以明白方法重载的意义了。就是接受不同的数据类型，接受不同数量的数据。这些完全根据具体的需要而定。完全没必要挨个的定义方法名。在大型类中，方法少了还好说，多了光是起名字就要耗费大量脑细胞。

方法重写：

出现在父子继承类当中。类与对象当中，对象是类的实现，实例化。子类是父类的实例化。

父类中的方法只需要一个存在的概念。而到了子类当中就必然要求根据子类的不同而出现不同的方法实现。这就是方法的重写，不过是为了更好的适用于子类而已。

就好像蚂蚁到了中国就必须与中国实际相结合才能发挥出相应的威力，不然不仅不能其正面作用，反而起副作用。必须做出佛.教中国化的改良一样，现在世界上也没有了佛.教，也同样没了蚂蚁，而只有中国才有，呵呵题外话。有助大家理解。放松一下心情。

这样一来重载出现在同类中，重写出现在继承得子类中。知道了这点，明白了存在的意义。才好记忆他们的其他区别。

方法的调用：

方法就好比武.器，属性就好比子.弹。制造出来就是让那来用的。不同的枪配不同的子弹，不同的搭配组合出来的效果不一样。

首先你就要会用。步.枪与机.枪的用法注意事项绝对不一样。橡胶.弹与穿.甲弹的使用方法也绝对不同。

不同的方法与变量的使用也绝对不同。

就方法的调用来说，基本上就三种。

第一。直接使用。本类中的诸多方法之间一般可以互相直接拿来使用。当然因为修饰符的权限不同。作用域可能不同。被static修饰的方法也可以直接被ststic方法拿来用。

第二种，间接使用。

在本类中用this调用。在父子类中用super调用。

第三，没有明显关系的类中。就必须首先创建要用方法所在类的对象，用变量名接受，然后才能调用。

其实就是new关键字的妙用。接触最早的new就是new Scanner（System.in）。当然这是系统的方法，我们一般都是自定义调用。通过实例化进行调用是最广泛的调用方法，可以说是万金油式的方法。

第四，其实还有一种调用的方法就是调用系统封装好的方法，导入系统方法，这个才是精华。就是import java.util.*;这个是重要的方法包。

最后介绍一种最常见最特殊的方法，主方法（主函数），也是常说的main方法。
public static void main(String[] args) {
}。

因为要对所有类公开，所以用public。因为第一时间运行加载，所以用static。因为没有所谓的具体返回值，所以用void。因为是程序主要入口，所以用main。主要说说main以及参数列表。因为要传递各种类型的数据，不可能用特定的类型。所以就用字符串数组类型，接受各种数据。
前面的几个修饰符跟其他地方的效力一样，所以不必再介绍了。所以主要说一下main和参数列表。
因为是程序运行的主要入口，所以用main（最重要的）修饰。main不是关键词。所以你定义一个属性或方法：String main="123";不会报错，也不知道为何。但没必要如此。
一个类里面只能有一个main。甚至为了不引起混乱，我们一般的一个小项目也只有一个main方法。也就是一般的测试类。当然你也可以创建两个测试类，分别测试不同的地方，就好像一个院子一般只有一个大门，你非得再开第二个，第三个大门，肯定有另外的用处。或者项目很大，打到一个城池需要九个城门的地步。
main函数在程序中大多数语言中都有存在。

再来看(String[] args)。意思就是一个String类型的数组参数，数组名，或者形参名叫做args。也不是关键字，是arguments的缩写，只是一个默认名，一般都习惯性照写。
所有的程序都是这样的，原生的是int Main(int argc,char** argv）
其中argv[0]是exe的路径，其他是参数。参数用空格分隔，与exe直接也用空格分隔。无论是c/c++/c#/java/vb等等程序都这样。这个主函数听说也是经历了数次演变才成为了今天的样子。
public class Demo
{
public static void main(String[] args)
{
System.out.println("打印main方法的输入参数");
for(int i=0;i<args.length;i++){
System.out.println(args[i]);
}
}
}

大家在cmd编译后运行的时候 在文件名后面输入任何数据。这段主函数可以随即将其输出。这就是主函数参数的传入与输出。
因为eclipse是编译与运行一体的，办不了这个小事情，所以只能cmd上场了。呵呵。

一星期的酝酿总结，七八个小时终于写完了，光一个方法全图就浪费了我好几个小时。肯定还有很多知识点没有涉及到，以后会继续编辑优化。谢谢。如果还有错漏，希望大家提出来。谢谢。