目录
1.扑克牌Demo
2.方法的定义
3.参数的值传递
4.可变参数
5.方法重载和构造方法
1.扑克牌Demo
一个小程序让大家了解方法的定义和使用
生成一副扑克牌：
1.首先要创建一张牌（包括点数和花色)，需要在Poker类定义点数和花色（此处只展示了主程序，Poker类的定义很简单，只需定义一个Poker类，在下面定义dot（点数）和pic（花色）属性就好了），便于在MyClass程序中直接使用Poker的两种属性；
2.生成保存点数和花色的数组；
3.生成保存所有扑克牌的数组，并用for循环用同一种方法创建整副扑克牌；
4.用增强for循环输出所有的扑克牌（视自己的需求而定，增强for循环对数组顺序没有要求。
另外，我们还需要有一些基础的了解
println 自动换行
print 不换行
数组一旦创建，内存空间确定，无法变化
在扑克牌的生成中，需要对数组进行访问，需要使用遍历数组的方法，把数组中所有元素全部体现出来
如何遍历一个数组
//1.for循环对数组进行操作
for (int i = 0; i < titles.length; i++) {
System.out.println(titles[i]);
}
//2.增强for循环（只关心你得到的，不关心是第几个）
for (String temp : titles){
System.out.println(temp);
有了以上基础后，我们一起来看看整个扑克牌Demo的实例吧：
public class MyClass {
public static void main(String[] args) {
{
//生成一副牌
//准备一个数组保存所有的点数
String[] dots = new String[]{
"2","3","4","5","6",
"7","8","9","10","J",
"Q","K","A"
};
//保存所有的花色
String[] pics = new String[]{"♠","♥","♣","♦"};
//保存所有的扑克牌
Poker[] pokers = new Poker[52];
int index = 0;//记录存到第几张扑克牌
for(String dot : dots){
for (String pic : pics){
//创建一张扑克牌
Poker poker = new Poker();
poker.dot = dot;
poker.pic = pic;
pokers[index] = poker;
index++;
}
}
//输出一副牌
for (Poker poker : pokers){
System.out.print(poker.dot + poker.pic + " ");
}
}
}
}
2.方法的定义
首先我们应该了解各种名词的性质
属性：类所具有的能引用的东西
方法：类的行为，类能做的事或具有的状态
类 -> 内部类：在类的内部，还可以定义这个类所具有的其他类，方便归类的区分
静态代码块：特点是在类加载的时候就执行
类方法=静态方法
对象方法=实例方法
- Java是面向对象的语言，一切皆对象 类，Java里面方法是不能独立存在的，只能在类里面声明
a.没有参数的实例方法：
public class Person {
//定义一个没有参数的实例方法
public void eat(){
}
但以下定义方法是错误的
public void eat(){
}
public class Person {
}
由此可知，方法必须定义在类里面，也就是说：方法是归类管辖的，不能越界。
b.有具体参数的实例方法：
public class Person {
public void work(String tool, String dest){
}
}
c.静态方法
和非静态方法的区别：
- 定义的区别：静态方法 使用static修饰
- 意义的区别：
1.静态方法依附于这个类本身，比实例方法优先被加载;
2.当这个类被加载到内存中，这个类就被加载了，而此时对象还不存在;
3.所以只能用这个类来调用静态方法;
4.对象方法依附于对象，必须创建这个类的一个对象，用对象来调用
static可以修饰以下内容
-变量 静态变量
-方法 静态方法
-类（内部类）静态内部类
下面是静态方法和实例（对象）方法的空间关系的运行先后顺序示意图
d.有返回值的方法
public String test(){
//做一定的操作
return "result";
}
下面演示四种方法的调用方法：
public class MyClass {
public static void main(String[] args) {
Person p = new Person();
p.eat();// 没有参数的实例方法
p.work(tool: "榔头",dest: "工地");//有参数的实例方法
String result = p.test();//想要返回值
p.test();//不想要返回值
Person.test2();//静态方法调用
}
}
3.参数的值传递
Java参数传递机制：值传递（传递过去的是当前变量的一份拷贝）
1.如果传递的是一个参数，则对方法无影响；
- 右边的函数将左边a的值拷贝过来，但是右边的操作不影响左边a的值。所以传递的是拷贝不是指针
public void eat(int a){
a++;
}
程序定义参数并赋值，然后将参数传递给eat()方法
{
int a = 10;
Person p = new Person();
p.eat(a);
System.out.println("a = " + a);
}
程序打印结果为：a = 10
2.如果传递的是一个对象，则方法会随对象赋值变化而变化（传递了对象的地址）。
首先，我们创建一个Car类，定义一个Car属性：WheelCount
public class Car {
public int wheelCount;
}
然后在Person类里面定义一个test3()方法，并把Car类定义的对象car传递过来，声明WheelCount = 4
public void test3(Car car){
car.wheelCount = 4;
}
我们在主程序里面给Car类定义一个对象bz，并声明Car bz的属性WheelCount = 8，然后将对象bz传递给Person类的test3()方法，让bz的属性WheelCount在test3()方法中运算后，赋值给对象bz，最后打印WheelCount的值
{
Car bz = new Car();
bz.wheelCount = 8;
Person p = new Person();
p.test3(bz);
System.out.println("wheel count is " + bz.wheelCount);
}
打印结果：
wheel count is 4
我们可以看到，虽然我们声明属性WheelCount时，数值为8，但是将对象bz传递给test3()方法计算过后，属性WheelCount的值最终变为4。由此可见，当传递对象时，方法会随着对象赋值变化而变化，也就是说，我们将这个对象进行了二次计算，最后赋值给这个对象。
我们来看看对象值传递的过程示意图吧
4.可变参数
首先在Person类里面创建一个有参数的test4()方法，但是不知道有多少参数，于是使用可变参数示意
}
//可变参数 参数的个数不一定
//使用数组来接收
//String ... agrs 等价于 String[] args;
public void test4(String ... args){
for (int i = 0; i < args.length; i++){
System.out.println(args[i]);
}
}
在主程序中调用test4()方法，并给参数赋值
{
Person p = new Person();
p.test4( ...args : "jack","rose","marry");
}
5.方法重载和构造方法
方法的重载：同一个类里面 方法名相同 参数一定不同
方法的重载和返回值、修饰符没有关系
例如以下两个方法，参数不同，方法名相同，就算方法的重载
public class Person {
public void eat(int a){
a++;
}
public void eat(float b){
}
}
构造方法：如何去创建一个对象
系统默认提供一个无参数的构造方法
特点：
- 方法名和类名相同；
- 没有返回值；
方法重载能解决两个问题
1.让代码更简洁；
例如以下两个方法调用的区别：
a.定义两个方法，第二个方法是第一个方法的重载
public Car(){
}
public Car(int count, int cEngine, int cSeat){
wheelCount = count;
engine = cEngine;
seat = cSeat;
}
b.在主函数调用两个方法
{
//调用第一个方法
Car c1 = new Car();
c1.wheelCount = 4;
c1.engine = 2;
c1.seat = 7;
//调用第二个方法
Car c2 = new Car( count : 4, cEngine : 2, cSeat : 7);
}
2.在数据使用时能保证有数据；
a.如果使用第一种方法，可能出现数据的丢失：
先调用test()方法再引用属性engine时：
{
Car c1 = new Car();
c1.test();
c1.engine = 3;
}
运行方法test()结果为：
engine count:0
先引用属性engine再调用test()方法时：
{
Car c1 = new Car();
c1.engine = 3;
c1.test();
}
运行方法test()结果为：
engine count:3
b.如果使用第二种方法，在创建方法时就进行了赋值操作，数据是不会丢失的
{
Car c2 = new Car( count : 3, cEngine : 2, cSeat : 7);
c2.test();
}
运行方法test()结果为：
engine count:2
总结
1.方法的创建和调用是编程中经常使用到的内容，必须要灵活掌握方法的使用；
2.方法的重载能在编程中让代码更简洁易懂，并且减少bug的产生；
3.在进行参数传递的操作中，一定要注意是仅对参数本身进行传递还是对对象进行了传递，对对象进行了传递就是地址的拷贝，会更改原有数据。
