类是面向对象的重要内容，可以把类当成一种自定义数据类型，可以使用类来定义变量，这种类型的变量统称为引用型变量。也就是说，所有类都是引用数据类型。
在面向对象的程序中，首先要将一个对象看作一个类。
类中各个成员之间的定义顺序没有任何影响，各个成员之间可以相互调用。但是需要注意的是，static修饰的成员不能访问没有static修饰的成员。类中成员包括：构造器、属性和方法。
在Java语言里，方法不能独立存在，不能单独定义一个方法。即所有方法必须使用“类.方法”或者“对象.方法”的格式来调用。当在同一个类的一个方法调用另外一个方法时，如果被调用方法是普通方法，则默认使用this作为调用者，如果被调用方法是静态方法，则默认使用类作为调用者。从表面上看起来某些方法可以被独立执行，但实际上还是使用this或者类来作为调用者。一旦将一个方法定义在某个类体内，如果这个方法使用了static修饰，则这个方法属于这个类，否则这个方法属于这个类的对象。
传递Java方法的参数的方式只有一种，即使用值传递方式。值传递是指将实际参数值的副本（复制品）传入方法中，而参数本身不会受到任何影响。
长度可变的方法：如果在定义方法时，在最后一个形参的类型后增加3点“...”则表明该形参可以接受多个参数值，多个参数值被当成数组传入。
//定义了形参个数可变的方法
public static void test(int a ,String...books){
//books被当成数组处理
for(String tmp:books){
System.out.println(tmp);
}
//输出整数变量a的值
System.out.println(a);
}
public static void main(String[] args) {
//调用test方法，为arges参数可以传入多个字符串
test(5,"AAA","BBB");
//调用test方法，为arges参数可以传入多个字符串
test(23,new String[]{"CCC","DDD"});
} 在上述代码中，当我们调用test( )方法时，books参数可以传入多个字符串作为参数值。从test( )方法体的代码来看，形参个数可变的参数其实就是一个数组参数。执行效果如下图所示：
构造方法：当使用一个类创建对象的时候，Java会调用该类的构造方法，构造方法的命名必须与类名一致，构造方法不能定义返回值类型声明，也不能用void定义构造方法没有返回值。在Java语言中如果把构造器定义了返回类型或者使用void定义构造方法没有返回值，编译时不会出错，但Java会把这个所谓的构造器当成方法来处理。
递归方法：如果一个方法在其方法体内调用它自身，这被称为方法的递归。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。当一个方法不断地调用它本身时，必须在某个时刻方法的返回值是确定的，即不再调用它本身。否则这种递归就成了无穷递归，类似于死循环。因此定义递归方法时规定：递归一定要向已知方向递归。
递归的作用：例如我们希望遍历某个路径下所有文件，但这个路径下的文件夹的深度是未知的，此时就可以使用递归来实现这个需求，在系统中可以定义一个方法，该方法接收一个文件路径作为参数，该方法可遍历出当前路径下所有文件和文件路径，即在该方法里再次调用该方法本身来处理该路径下所有文件路径。
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));
} 在上述代码中，对于fn（10）来说，等于2*fn(9)+fn(8)，其中fn(9)又等于2*fn(8)+fn(7)+......以此类推，最终得到fn(2)等于2*fn(1)+fn(0)，即fn(2)是可以计算的，然后一路反算回去，就可以最终得到fn(10)的值。
Java规定可以使用关键字this去访问全局变量，this关键字总是指向调用的对象。根据this出现位置的不同，this作为对象的默认引用有两种情况：（1）在构造器中引用该构造器执行初始化的对象；（2）在方法中引用调用该方法的对象。
public class Try01 {
//定义全局变量
public String color="粉红色的";
public void hu(){
//定义局部变量
String color="咖啡色的";
//此处应用了局部变量
System.out.println("她得外套是"+color);
//此处应用了全局变量
System.out.println("她的外套是"+this.color);
}
public static void main(String[] args) {
Try01 a=new Try01();
a.hu();
}
}执行后的效果为：
静态变量和静态方法访问只需要类名，通过运算“.”即可实现对变量的访问和对方法的访问。意思就是只能通过类名访问。
关键字abstract修饰的类是抽象类，修饰的方法时抽象方法，抽象方法不能有方法体。如果一个类不想被实例化，可以没有抽象方法而把这个类定义为抽象类。使用它们的规则有：
（1）抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器来创建抽象类的实例。
（2）抽象类可以不包含抽象方法，抽象类里可以包含属性、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类、枚举类6种成分。抽象类的构造器不能用于创建实例，主要用于被其子类调用。
（3）含有抽象方法的类只能被定义成抽象类。（包括直接定义了一个抽象方法；集成了一个抽象父类，但没有完全实现父类包含的抽象方法；以及实现了一个借口，但没有完全实现接口包含的抽象方法3种情况）
抽象方法和空方法体的方法不是同一个概念。例如public abstract void test( )是一个抽象方法，他根本没有方法体，即方法定义后面没有一对花括号。但public void test( ){ }是一个普通方法，他已经定义了方法体，只是这个方法体为空而已。
abstract class Fruit{
//定义抽象类
public String color;
public Fruit(){
//定义构造方法
color="红色";
}
public abstract void harvest();
//定义
}
class apple extends Fruit{
public void harvest(){
System.out.println("苹果已经收获！");
}
}
public class Try01 {
public static void main(String[] args) {
System.out.println("调用苹果类的harvest()方法的结果:");
apple Apple=new apple();
Apple.harvest();
}
}抽象类的作用：抽象类不能被实例化，它只能被当成父类来继承。从语义角度来看，抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象，从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了之类设计的随意性。抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会大致保留抽象类的行为方式。如果编写一个抽象父类，父类提供多个子类的通用方法，并把一个或多个方法留给其子类实现，这就是一种模板模式。模板模式也是最常见、最简单的设计模式之一。
public abstract class moban{
//转速
private double turnRate;
public moban(){ }
//把返回车轮半径的方法定义成抽象方法
public abstract double getRadius();
public void setTurnRate(double turnRate){
this.turnRate=turnRate;
}
//定义计算速度的通用算法
public double getSpeed(){
//速度等于 车轮半径*2*PI*转速
return java.lang.Math.PI*2*getRadius()*turnRate;
}
} public class Try01 extends moban{
public double getRadius() {
return 0.28;
}
public static void main(String[] args) {
Try01 csm= new Try01();
csm.setTurnRate(15);
System.out.println(csm.getSpeed());
}
}使用模板模式的两条规则：（1）抽象父类可以只定义需要使用的某些方法，其余则留给其子类实现。（2）父类中可能包含需要调用其他系列方法的方法，这些被调方法既可以由父类实现，也可以由其子类实现。在父类中提供的方法只是定义了一个通用算法，其实现也许并不完全由自身实现，而必须依赖于其子类的辅助。
String是引用类型，传递的也是引用类型，除了8种基本类型之外，在java中其余类型都是引用类型（比如说数组）。
扫一扫
446
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
