注意点
- Java中的方法一定是位于类中的
- Java中的方法中可以调用属性（同一个类中的调用属性，不同类调用属性）
- Java中的方法中可以调用方法（同一个类中的调用方法，不同类调用方法）
- Java中的方法中可以定义变量（局部变量的范畴）
- Java中的方法中不可以定义方法
调用某个类中的属性或者是方法时，到底需不需要造对象（注意是造谁的对象）
下面以方法A中调用方法B为例子进行解释
- 需要造对象
当方法A中含有Static关键字的时候，那么方法A调用方法B时，我们是需要再方法A中造对象。但是，是造A方法所位于的类的对象，还是造B方法所位于的类的对象呢？
很显然，B方式是被调用的，那么我们应该造B方法所位于类的对象
- 不需要造对象（直接在A方法中调用B方法）这里又分为两种情况
情况一：方法A和方法B在同一个方法内，这个时候，直接调用在方法A中，直接调用方法B就行
情况二：方法A和方法B不在同一个方法内，这个时候，我们可以通过在方法A内的形参列表中定义一个方法B的类的形参列表，这样通过方法B所位于的类的地址来调用方法B
以下给出上面提到的例子对应的代码
要造对象
package com.atcug.java;
/*
交换两个数的值，通过引用数据类型(通过对象(创建类的方式，将实参为引用数据类型的数据传递给形参)，通过数组)
来交换两个数的值，而不是通过基本数据类型来交换两个数的值
*/
public class ValueTransfer1 {
public static void main(String[] args) {
Data1 data1 = new Data1();
data1.m = 10;
data1.n = 20;
System.out.println("交换前: ");
System.out.println("m = " + data1.m + "\t n = " + data1.n);
ValueTransfer1 test = new ValueTransfer1();
test.swap(data1);
//输出交换后的结果
System.out.println("交换后: ");
System.out.println("m = " + data1.m + "\t n = " + data1.n);
}
//方法中是不能定义方法的
public void swap(Data1 data1) {
int temp = data1.m;
data1.m = data1.n;
data1.n = temp;
}
}
class Data1{
//属性
int m;
int n;
//方法
}
不需要造对象
情况一：A和B在同一个方法内
import java.util.Scanner;
/**
Utility工具类：
将不同的功能封装为方法，就是可以直接通过调用方法使用它的功能，而无需考虑具体的功能实现细节。
*/
public class Utility {
private static Scanner scanner = new Scanner(System.in);
/**
用于界面菜单的选择。该方法读取键盘，如果用户键入’1’-’4’中的任意字符，则方法返回。返回值为用户键入字符。
*/
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1);
c = str.charAt(0);
if (c != '1' && c != '2' && c != '3' && c != '4') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
/**
用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数，并将其作为方法的返回值。
*/
public static int readNumber() {
int n;
for (; ; ) {
String str = readKeyBoard(4);
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
用于收入和支出说明的输入。该方法从键盘读取一个不超过8位长度的字符串，并将其作为方法的返回值。
*/
public static String readString() {
String str = readKeyBoard(8);
return str;
}
/**
用于确认选择的输入。该方法从键盘读取‘Y’或’N’，并将其作为方法的返回值。
*/
public static char readConfirmSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return c;
}
private static String readKeyBoard(int limit) {
String line = "";
while (scanner.hasNext()) {
line = scanner.nextLine();
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
continue;
}
break;
}
return line;
}
}
特别注意的是，上面两张图片中的A方法调用B方法(A方法和B方法不在同一个类当中，把B方法中的结果返回给了A方法)
情况二：A和B不在同一个方法内
package com.atcug.java;
public class PhoneTest {
public static void main(String[] args) {
//匿名化对象，也就是说在实例化对象的时候，并没有把创建的实例化对象赋值给一个变量
//这样会导致，用完一次后，下次这个匿名化的对象就用不了，相当于只能用一次
//那么如何解决上面遇到的这个问题呢？
//解决方法，也就是在开发中经常用到的方式
//就是依然创建匿名对象，然后这个对象赋值给一个局部变量，使得这个变量可以用多次
//注意这个局部变量的数据类型和创建的匿名对象是同一个类型的
//new Phone()
//new PhoneMall().show(new Phone());
PhoneMall mall = new PhoneMall();
mall.show( new Phone());
}
}
//对类中的方法可以调用属性，调用方法，可以定义变量，但是不能定义方法的理解
/*
个人目前的理解:
类中的方法可以调用该类中的属性，也可以调用别的类中属性（通过在方法中定义一个变量的形式来实现，类似于这里的class PhoneMall）
类中的方法可以调用该类中的方法，也可以调用别的类中的方法（通过在方法中定义一个变量的形式来实现，类似于这里的class PhoneMall）
类的方法中可以定义变量，比如方法内的形参以及方法内的变量（二者统称为局部变量）
*/
//很重要的一点是: 只要像调用某个类中的属性或者是方法，我们就必须要首先创建该方法或者是属性所位于类中的一个对象(不管是否是匿名的对象)
//class PhoneMall 和 class Phone很好的诠释了不同类中，方法的调用实现方式
class PhoneMall{
public void show(Phone phone) {
phone.playGames();
}
}
class Phone{
//属性
double price;
//方法
public void playGames() {
System.out.println("手机可以用来玩游戏");
}
}
另外看视频学到现在，我发现以下几点：
- 对象的创建基本都是在main方法中完成的
- 有的方法写在和main方法相同的类里面（注意不是写在main方法里面，因为方法内是不能定义方法的），比如：下面是常见到的情况
package com.atcug.java;
/*
交换两个数的值，通过引用数据类型(通过对象(创建类的方式，将实参为引用数据类型的数据传递给形参)，通过数组)
来交换两个数的值，而不是通过基本数据类型来交换两个数的值
*/
public class ValueTransfer1 {
public static void main(String[] args) {
Data1 data1 = new Data1();
data1.m = 10;
data1.n = 20;
System.out.println("交换前: ");
System.out.println("m = " + data1.m + "\t n = " + data1.n);
ValueTransfer1 test = new ValueTransfer1();
test.swap(data1);
//输出交换后的结果
System.out.println("交换后: ");
System.out.println("m = " + data1.m + "\t n = " + data1.n);
}
//方法中是不能定义方法的
public void swap(Data1 data1) {
int temp = data1.m;
data1.m = data1.n;
data1.n = temp;
}
}
class Data1{
//属性
int m;
int n;
//方法
}
上面代码中的swap方法，其实我们可以这样想该方法中用到了data1这个实例化对象，然后根据前面提到的 \t “对象的创建和实例化基本都是在main方法中完成的”\t，所以我们推断该方法最好就放在main方法所位于的类的一个类当中。
###这个地方，自己想把swap方法放在和main方法不同的类里面，目前显示编译出错，还没有调整过来，后面再试试看，看看行不行。自己写的代码具体如下所示：
package com.atcug.java;
/*
交换两个数的值，通过引用数据类型(通过对象(创建类的方式，将实参为引用数据类型的数据传递给形参)，通过数组)
来交换两个数的值，而不是通过基本数据类型来交换两个数的值
*/
public class ValueTransfer2 {
public static void main(String[] args) {
Data2 data2 = new Data2();
data2.m = 10;
data2.n = 20;
System.out.println("交换前: ");
System.out.println("m = " + data2.m + "\t n = " + data2.n);
ValueTransfer2 test = new ValueTransfer2();
test.swap2(data2);
// 输出交换后的结果
System.out.println("交换后: ");
System.out.println("m = " + data2.m + "\t n = " + data2.n);
}
}
class Data2 {
// 属性
int m;
int n;
// 方法
// 方法中是不能定义方法的 后面看看这个能否接着改改
public void swap2(Data2 data2) {
int temp = data2.m;
data2.m = data2.n;
data2.n = temp;
}
}
其它的总结
- 通过将形参设置为应引用数据类型（类，数组，接口）来达到基本数据类型作为形参所不能解决的问题，这样就涉及到类的设计，方法和对象的创建等问题
- 学会设计程序，使得方法中调用方法得以实现
- 学会使用return
下面给出一个面向过程编程与面向对象编程的程序对比图
题目：使用冒泡法将一个数组的数，按照从小到大进行排序
面向过程：
package com.atcug.java;
//使用冒泡法进行排序,按照从小到大的顺序进行排序
public class BubbleTest {
public static void main(String[] args) {
int[] arr1 = new int[] {12,-89,2,-120,56,26};
System.out.println("排序前: ");
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
System.out.println("\n");
//冒泡法排序
for(int i = 0; i <arr1.length - 1; i++) {
for(int j = 0; j < arr1.length - 1 -i; j++) {
if(arr1[j] > arr1[j+1]) {
int temp = arr1[j];
arr1[j] = arr1[j+1];
arr1[j+1] = temp;
}
}
}
System.out.println("排序后: ");
//将排序后的结果，用for循环进行遍历输出
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
}
}
面向对象：
创建一个ArraysUtil的工具类，这个类里面包含需要用到的方法
package com.atcug.java;
public class ArrayUtil {
// 创建冒泡的方法,冒泡方法中的值交换又可以作为一种方法出现
public void sort(int[] arr1) {
for (int i = 0; i < arr1.length - 1; i++) {
for (int j = 0; j < arr1.length - 1 - i; j++) {
if (arr1[j] > arr1[j + 1]) {
swapValue(arr1, j, j + 1);
}
}
}
}
// 值交换方法
public void swapValue(int[] arr1, int i, int j) {
int temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}
// 遍历数组输出的方法
public void print(int[] arr1) {
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
}
}
包含main方法的类
package com.atcug.java;
//使用冒泡法进行排序,按照从小到大的顺序进行排序
public class BubbleTest {
public static void main(String[] args) {
int[] arr1 = new int[] {12,-89,2,-120,56,26};
ArrayUtil test = new ArrayUtil();
System.out.println("排序前: ");
test.print(arr1);
System.out.println("\n");
//冒泡法排序
test.sort(arr1);
//将排完序后的结果输出
System.out.println("排序后: ");
test.print(arr1);
}
}
上面给出类一种正确的情况
下面给出一种错误的情况（并没有实现数组的冒泡排序，错误原因，是属于基本数据类型的参数传递）
package com.atcug.java;
public class ArrayUtil {
// 创建冒泡的方法,冒泡方法中的值交换又可以作为一种方法出现
public void sort(int[] arr1) {
for (int i = 0; i < arr1.length - 1; i++) {
for (int j = 0; j < arr1.length - 1 - i; j++) {
if (arr1[j] > arr1[j + 1]) {
swapValue(arr1[j], arr1[j+1]);
}
}
}
}
// 值交换方法
public void swapValue(int i, int j) {
int temp = i;
i = j;
j = temp;
}
// 遍历数组输出的方法
public void print(int[] arr1) {
for (int i = 0; i < arr1.length; i++) {
System.out.print(arr1[i] + "\t");
}
}
}
package com.atcug.java;
//使用冒泡法进行排序,按照从小到大的顺序进行排序
public class BubbleTest {
public static void main(String[] args) {
int[] arr1 = new int[] {12,-89,2,-120,56,26};
ArrayUtil test = new ArrayUtil();
System.out.println("排序前: ");
test.print(arr1);
System.out.println("\n");
//冒泡法排序
test.sort(arr1);
//将排完序后的结果输出
System.out.println("排序后: ");
test.print(arr1);
}
}
运行的结果为：
错误点
527
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
