java定义一个eat方法,java基础5&实战开发Day2/方法/2020-04-26

目录

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.在进行参数传递的操作中，一定要注意是仅对参数本身进行传递还是对对象进行了传递，对对象进行了传递就是地址的拷贝，会更改原有数据。