java学习笔记——第八章 类和方法（二）

8.4使用方法
java中的方法不能独立存在，他必须属于一个类或者一个对象，因此方法也不能像函数那样被独立执行。因此必须使用类或对象来调用。
总结：

• 方法不能独立定义，方法只能在类体中定义。
• 逻辑上讲，方法要么属于该类本身，要么属于该类的一个对象。
• 永远不能独立执行方法，执行方法必须使用类或对象作为调用者。

调用方法也必须使用类或对象作为主调者，如果在声明方法时包含形参声明，则调用方法时必须给这些形参指定参数值。调用方法时，实际传给形参的参数值也被称为实参。
例如：

public class chuandi {
	public static void swap(int a , int b)
	{
		int tmp=a;
		a=b;
		b=tmp;
		System.out.println("swap方法里，a的值是"+a+";b的值是"+b);
	}
	public static void main(String args[])
	{
		int a=6;
		int b=9;
		swap(a,b);
		System.out.println("交换后，实参a的值是"+a+"：实参b的值是"+b);
	}
}

长度可变的方法
在java中定义形参长度可变的参数，从而允许为方法指定数量不确定的形参。在最后一个形参类型后增加三点"…"，则表明该形参可以接受多个参数值。
例如：

public class Bian {
	public static void test(int a, String... books)
	{
		//book被当成数组处理
		for(String tmp : books)
		{
			System.out.println(tmp);
		}
		System.out.println(a);
	}
	public static void main(String args[])
	{
		//调用test方法，为args参数可以传入多个字符串
		test(2000,"歼15","歼20");
		test(1400,new String[] {"歼10B","歼20B"});
		//调用test方法，为args参数可以传入多个字符串
	}
}

结果：

歼15
歼20
2000
歼10B
歼20B
1400

构造方法
当使用一个类创建对象的时候，java会调用该类的构造方法，构造方法命名必须与类名一致。格式如下：

[构造方法修饰符] 方法名 ([参数列表])
{
	方法体
}

例如：

public class leione {
	String gname;
	int gid;
	float gprice;
	public void print()
	{
		System.out.println(gname+"，产品序列号"+gid+"，造价成本是"+gprice+"万美元");
	}
	public static void main(String args[])
	{
		leione book1=new leione();
		book1.gname="歼10B";
		book1.gid=10005601;
		book1.gprice=4000;
		book1.print();
		leione book2=new leione();
		book2.gname="歼20B";
		book2.gid=12225601;
		book2.gprice=6500;
		book2.print();
	}
}

递归方法
一个方法在其方法内调用自身，称之为递归。
例如计算f（10）：

public class digui {
	public static int fn(int n)
	{
		if(n==0)
		{
			return 1;
		}
		else if(n==1)
		{
			return 4;
		}
		else
		{
			return 2* fn(n-1)+fn(n-2);
		}
	}
	public static void main(String args[])
	{
		System.out.println(fn(10));
	}
}

8.5使用this关键字
java中使用this的关键字去访问全局变量。语法格式如下：

this.成员变量名
this.成员方法名（）

例如：

public class leithree1 {
	public String color="粉红";
	public void hu()
	{
		String color="咖啡";
		System.out.println("歼20的涂装颜色是"+color+"色的");
		System.out.println("歼15的涂装颜色是"+this.color+"色的");//访问全局变量
	}
	public static void main(String args[])
	{
		leithree1 bb=new leithree1();
		bb.hu();
	}
}

结果：

歼20的涂装颜色是咖啡色的
歼15的涂装颜色是粉红色的

8.6使用类和对象
在java中使用对象的方法和变量，通过点 “."实现对变量的访问和对方法的调用。
创建和使用方法
在java中，一般通过关键字new 来创建对象。电脑会自动为对象分配一个空间，然后访问变量和方法。
例如：

public class leidui1 {
	int X=12;
	int Y=23;
	public void printFoo()
	{
		System.out.println("X="+X+",Y="+Y);
	}
	public static void main(String args[])
	{
		System.out.println("坐标是:");
		leidui1 Z=new leidui1();
		Z.X=41;
		Z.Y=75;
		Z.printFoo();
		leidui1 B=new leidui1();
		B.X=23;
		B.Y=38;
		B.printFoo();
	}
}

使用静态变量和静态方法
在java中只要使用static修饰某个变量和方法，就被称作静态变量和静态方法。
访问静态方法时，只需要类名.，即可实现对变量的访问和方法调用。
例如：

public class leijing1 {
	static int Y;
	static int X;
	public void printJingTai()
	{
		System.out.println("X="+X+",Y="+Y);
	}
	public static void main(String args[])
	{
		leijing1 Aa=new leijing1();
		System.out.println("改变飞机计划，战斗即将飞往新的领域，具体坐标是：");
		Aa.X=4;
		Aa.Y=5;
		leijing1.X=112;
		leijing1.Y=252;
		Aa.printJingTai();
		leijing1 Bb=new leijing1();
		Bb.X=3;
		Bb.Y=8;
		leijing1.X=131;
		leijing1.Y=272;
		Bb.printJingTai();
	}
}

结果：

改变飞机计划，战斗即将飞往新的领域，具体坐标是：
X=112,Y=252
X=131,Y=272

8.7抽象类和抽象方法
使用静态变量和静态方法
在java中，使用 abstract修饰符来定义抽象类和抽象方法。
抽象类：是指只声明方法的存在而不去实现它的类，抽象类不能实例化，不能创建对象。
格式如下:

abstract class 类名{
类体
}

在java中抽象方法和抽象类的规则如下：

• 抽象类、抽象方法必须使用abstract修饰符来修饰，方法不能有方法体。
• 抽象类不能被实例化，无法使用new关键字。
• 抽象类里不包含抽象方法，这个抽象类也不能创建实例。
• 抽象类可以包含属性、方法。主要被子类调用。
• 含有抽象方法的类，只能被定义为抽象方法。

public abstract test()

是一个抽象方法，根本没有方法体，即定义后没有一对花括号。

public void test(){}

是一个普通方法，他已经定义了方法体，只不过这个方法体{}是空的而已。
例如:
（1）新建一个Fruit抽象类。

public abstract class Fruit {
	//定义抽象类
	public String color;
	//定义构造的方法
	public Fruit()
	{
		color="红色";
	}
	//定义抽象方法
	public abstract void harvest();
}

（2）因为抽象类不会具体实现，新建一个苹果类来继承这个抽象类。

public class pingguo extends Fruit{
	public void harvest()
	{
		System.out.println("苹果已经收货！");
	}
}

（3）新建一个橘子类。

public class Juzi extends Fruit{
	public void harvest()
	{
		System.out.println("橘子已经收获！");
	}
}

（4）新建一个zong类。

public class zong {
	public static void main(String args[])
	{
		System.out.println("调用苹果类的harvest方法结果如下：");
		pingguo pinguo = new pingguo();
		pinguo.harvest();
		System.out.println("调用橘子类的harvest方法结果如下：");
		Juzi orange = new Juzi();
		orange.harvest();
	}
}

输出结果：

调用苹果类的harvest方法结果如下：
苹果已经收货！
调用橘子类的harvest方法结果如下：
橘子已经收获！

抽象类必须有一个抽象方法
java中，抽象类最大的规则就是：抽象类必须有一个抽象方法
例子：

abstract class cou
{
	int a1;
	int b1;
	cou(int a,int b)
	{
		a1=a;
		b1=b;
	}
	abstract int mathtext();//抽象方法
}
class cou1 extends cou
{
	cou1(int a,int b)
	{
		super(a,b);
	}
	int mathtext()
	{
		return a1+b1;
	}
}
class cou2 extends cou
{
	cou2(int a,int b)
	{
		super(a,b);
	}
	int mathtext()
	{
		return a1-b1;
	}
}
public class leichou {
	public static void main(String args[])
	{
		cou1 abs1=new cou1(3000,2000);
		cou2 abs2=new cou2(4000,2000);
		cou abs;
		abs=abs1;
		System.out.println("加油后，是多少："+abs.mathtext());
		abs=abs2;
		System.out.println("开过后，是多少："+abs.mathtext());
	}
}

输出结果：

加油后，是多少：5000
开过后，是多少：2000

抽象类的作用
抽象类不能创建实例，只能当作父类来被继承。
从语义角度看，抽象类是从多个具体类中抽象出来的父类，具有更高层次的抽象，以这个抽象类作为其子类的模板。
例子：父类的普通方法依赖于一个抽象方法，而抽象方法则推迟到子类中去实现。