- 方法（Methods）
程序设计是为了使用程序的某些功能，帮助解决问题。在其他编程语言中，我们称Java的“方法”为子程序（Subroutine）/函数（Function）。
1.1方法的定义
java为面向对象语言，其方法与变量一样，每一种方法均有其所属的类对象，由类整合多个方法，组成一个具有特定功能的类对象。每一方法也可视为一个块。使用方法时注意其类对象属性，参数以及返回值规则，即
1.在类中，以声明(Declare)创建方法(Methods)。
2.若声明的方法不执行返回数据，则必须前置void；若要执行返回数据，则不得前置void。在内容中必须有return。简而言之，void与return不能同时存在。
3.使用方法(Methods)时，须先将所属类以new产生新对象，再运行新对象内的方法。
4.使用方法时，要注意调用程序与被调用程序间的参数，须保持一致性，即（a）参数类型要一致。若违反此类型规则，程序将无法运行。
class Study {
int credit = 0;
void addcredit(int i) {
credit +=i;
}
int totalcredit() {
return credit;
}
}
public class Student {
public static void main(String[] args) {
Test a = new Test();
Test b = new Test();
a.addcredit(12);
b.addcredit(9);
b.addcredit(6);
System.out.println("a.addcredit:"+a.totalcredit());//12
System.out.println("b.addcredit:"+b.totalcredit());//15
}
}
1.2实例方法(Intance Methods)
只有当方法所属类对象存在时，该方法才可被运行使用，这样随所属对象存在而存在的方法称为“实例方法”。
public class Number {
int n=0;
void addN(int i) {
n=i;
}
int getN() {
return n;
}
}
public static void main(String[] args) {
Number N; //删除后报错
N = new Number();//删除报错
N.addN(10);
System.out.println("使用方法 N.getN:"+N.getN());//10
}
- 类方法(Class Methods)
在方法声明时，前置"static"即可将该声明的方法一直保持存在，不必经过产生新对象的过程，可直接被运行，称为“类方法”。
public class Number {
static int n=0;
static void addN(int i) {
n=i;
}
static int getN() {
return n;
}
}
public static void main(String[] args) {
Number.addN(10);
System.out.println(" N.getN:"+Number.getN());//10
Number.n = 20;
System.out.println("Number.n:"+Number.n);//20
}
类方法和实例方法相比，可以不再new对象了，可以直接使用static中的变量。
- 构造函数(Constructor)
类的构造函数特征有：
1.构造函数名称必须与所属类的名称相同。
2.构造函数是方法，与其他一般方法不同，无返回数据(无return)，也无前置void。
3.构造函数在所属类产生新对象进行初始化运行。
4.在类中，如果没有构造函数，系统将会自动给予一个默认的隐藏空白构造函数(Default Constructor)。
public class Mynumber {
int n;
Mynumber(){
n = 3;
System.out.println("Here is Constructor and n="+n);
}
int getnumber() {
return n;
}
}
public static void main(String[] args) {
Mynumber a = new Mynumber();
System.out.println("Here is main and a.getnumber()="+a.getnumber());//3
}
4.方法重载(Method Overload)
类内有多个方法，名称相同，功能相同，但参数不同；参数的数据类型和数量不同。当类被调用运行时，参数类型与数量均符合的方法，自动出面接受运行，这样的对象称为“方法重载”。
public class adder {
int add(int a,int b) {
return a+b;
}
double add(double a, double b) {
return a+b;
}
int add(int x, int y, int z) {
return x+y+z;
}
}
public static void main(String[] args) {
int j;
double k;
int m;
adder ad = new adder();
j=ad.add(5, 7);
k=ad.add(1.2, 1.32);
m=ad.add(12, 12,52);
System.out.println("j="+j);//12
System.out.println("k="+k);//2.52
System.out.println("m="+m);//76
}
- 构造函数重载
public class adder {
int c;
double k;
adder(int a,int b) {
c=a+b;
System.out.println("int c="+c);
}
adder(double a, double b) {
k=a+b;
System.out.println("double k="+k);
}
}
public static void main(String[] args) {
adder add_int = new adder(2,3);//5
adder add_double = new adder(13.2,2.3);//15.5
}
- public/private修饰符(Modifications)
在类内声明变量(Variables)或方法(Methods)均可前置修饰符public和private,以限制其使用环境与时机。
1.当变量(Variables)和方法(Methods)前置修饰符public时，即为公共变量或公共方法，其他类对象均可运行调用。
2.当变量和方法前置修饰符private时，即为私有变量或私有方法，只允许自身类对象内的方法使用，其他类对象不得运行调用。
3.当无任何前置修饰符时，是默认设置（Default），允许在同一包(package)内运行调用，在不同包内，则无法调用。另外修饰符protected也有相同的功能。
6.1 无前置修饰(Default Modifications)
class Number {
int number;
}
public class Lab {
public static void main(String[] args) {
Number i = new Number();
i.number=10;
System.out.printf("i.n=%d",i.number);//i.number=10
}
}
注：当变量、方法无任何前置修饰符时，为默认设置(Default)，仅允许在同一包(package)内被运行调用，在不同包内 不能使用。
6.2前置修饰符public
public class Number {
public int N;
}
import text_two.Number;
public class Lab {
public static void main(String[] args) {
Number i = new Number();
i.N=10;
System.out.printf("i.N=%d",i.N);//i.N=10
}
}
不同包中必须导包：格式：import <包名>.<类名>;并且被导包的类必须是前置public，如果是在同一包下，则只需要变量前置public关键字。
6.3 当变量、方法前置修饰符private时，只允许自身类对象内的方法使用，其他类对象不得调用。
class Study {
private int credit = 0;
public void addcredit(int i) {
credit +=i;
}
public int totalcredit() {
return credit;
}
}
public class Lab {
public static void main(String[] args) {
Study joe = new Study();
Study george = new Study();
joe.addcredit(12);
george.addcredit(9);
joe.addcredit(6);
george.addcredit(3);
System.out.println("joe studied:"+joe.totalcredit()+"credites");//joe studied:18credites
System.out.println("george studied:"+george.totalcredit()+"credites");//george studied:12credites
}
}
- this 关键字
当一个构造函数以this()调用另一个重载构造函数时，this()必须放在该构造函数的第一行。
7.1类
在一个复杂的类中，为了简化程序设计，增加程序可读性，将this用于方法内，其意义为所属类对象的关键字。
class Mynumber {
private int n;
public void setnumber(int i) {
this.n=i;
}
public int getnumber() {
return n;
}
}
public class Lab {
public static void main(String[] args) {
Mynumber M = new Mynumber();
M.setnumber(10);
System.out.println("My.getnumber:"+M.getnumber());
}
}
