一、方法
（一）方法的定义
修饰符 返回值类型 方法名(参数类型 参数名)
{
...
方法体
...
[return 返回值;]
}eg:
/** 返回两个整型变量数据的较大值 */ public static int max(int num1, int num2) { int result; if (num1 > num2) result = num1; else result = num2; return result; }补充：“static的使用”
static成员的特点是它们不依赖于类的实例，而是属于整个类。因此，你可以通过类名直接访问静态成员，而不需要创建对象。1.静态变量：在类中定义一个变量为
static，那么这个变量将成为类的属性，而不是对象的属性。public class MyClass { public static int count; // 静态变量，所有实例共享 }2.静态方法：静态方法属于类，而不属于类的实例。它可以通过类名直接调用，而无需创建类的实例。通常用于工具类或不依赖于对象状态的方法。
public class MathUtils { public static int add(int a, int b) { return a + b; } }
（二）方法的调用和参数传递
1.方法的调用
（1）当方法返回一个值的时候，方法调用通常被当做一个值。
int larger = max(30, 40);（2）如果方法返回值是void，方法调用一定是一条语句。（方法中用的println打印）
2.参数传递
（1）必须按照参数列表提供的顺序
（2） 参数传递是按值传递的，这意味着当你将参数传递给方法时，实际上是将参数值的拷贝传递给了方法，而不是参数本身。因此，如果你在方法内部交换了两个参数的值，不会影响到原始参数的值。（和c一样）
（三）构造方法
（1）当一个对象被创建时候，构造方法用来初始化该对象。
（2）构造方法和它所在类的名字相同，但构造方法没有返回值。
（3）所有的类都有构造方法，因为 Java 自动提供了一个默认构造方法，默认构造方法的访问修饰符和类的访问修饰符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。一旦你定义了自己的构造方法，默认构造方法就会失效。
public class test1 { int a; test1(int i)//带参构造函数 { a=i; } public static void main(String[] args) { test1 x=new test1(20); test1 y=new test1(10); System.out.println(x.a+y.a); } }
[public][abstract][final] class classname
[extends superclass][implements InterfaceNameList]
{
}
(4)implements InterfaceNameList:实现哪些接口成员：成员变量和成员方法
1.成员变量的声明：
[public|protected|private] [static][final][transient][transient][volatile]
type variableName[=value];
解释：
（1）[public|protected|private] ：访问范围
（2）[static]：静态变量（类变量）
（3）type：类型int，float，string...
2.成员方法的声明：（与声明函数类似）
[public|protected|private] [static] [final|abstract][native][synchronized]
return Type methodName( )
二、类和对象
public class dog
{
//成员变量
String breed;
int size;
String colour;
int age;
//成员变量
dog(String b,int s,String c,int a)//构造方法
{
breed=b;
size=s;
colour=c;
age=a;
}
void eat()//方法
{
int a;//局部变量
Scanner cin=new Scanner(System.in);
a=cin.nextInt();
System.out.println(this.breed+" eat "+a);
}
public static void main(String[] arg)
{
dog a=new dog("dog13",2,"red",5);
a.eat();
}
}1. 类
（1）局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
（2）成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。成员变量前可以加public，private，protect来设置权限
1）public：具有
public修饰符的成员变量可以被任何类访问。它们具有最广泛的访问权限。2）private：具有
private修饰符的成员变量只能被定义它们的类内部访问。其他类无法直接访问它们。3）protected：具有
protected修饰符的成员变量可以在同一包内的其他类中访问，以及继承该类的子类中访问。4）默认（包内访问）：如果成员变量没有显式指定访问修饰符，则它们具有默认的包内访问权限。这意味着它们可以在同一包内的其他类中访问，但对于不在同一包内的类来说是不可见的。
（3）类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
2. 创建对象
格式：类名 对象名=new 类名(参数);
dog a=new dog("dog13",2,"red",5);
三、继承
1. 格式：
class 父类 {
}
class 子类 extends 父类 {
}2. 类型
3. 特性
子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。
4. super 与 this 关键字
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。
//（1）在子类调用超类中的构造方法 super([paramlist]) //（2）在子类调用超类中被覆盖的方法 super.methodName([paramlist]) //（3）在子类调用超类中被隐藏的成员变量 super.variableName5. final
四、重写和重载
1. 重写
定义：重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
public class animal { public void sleep() { System.out.println("动物睡觉"); } }//动物类 public class dog extends animal { public void sleep() { System.out.println("狗白天睡觉"); } public static void main(String[] arg) { animal b=new animal(); animal a=new dog(); b.sleep(); a.sleep(); } }结果：
动物睡觉 狗白天睡觉规则：
参数列表与被重写方法的参数列表必须完全相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个类，则不能重写该类的方法。
2. 重载
定义：重载(overloading) 是在一个类里面，方法名字相同，而参数不同。
规则：
- 被重载的方法必须改变参数列表(参数个数或类型不一样)；
- 被重载的方法可以改变返回类型；
- 被重载的方法可以改变访问修饰符；
- 被重载的方法可以声明新的或更广的检查异常；
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
3. 零零碎碎
重写是类与类之间方法同名的情况；重载是一个类中方法同名。
| 区别点 | 重载方法 | 重写方法 |
|---|---|---|
| 参数列表 | 必须修改 | 一定不能修改 |
| 返回类型 | 可以修改 | 一定不能修改 |
| 异常 | 可以修改 | 可以减少或删除，一定不能抛出新的或者更广的异常 |
| 访问 | 可以修改 | 一定不能做更严格的限制（可以降低限制） |
五、多态
多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象：Parent p = new Child();
使用这种方式创建的对象可以访问 Parent 类中声明的方法和成员变量，但不能访问 Child 类特有的方法或成员变量，除非进行类型转换。
//类型转换 Parent a=new Child(); Child c=(Child)a;
六、抽象
（1）抽象类
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。抽象类必须被继承才能使用。
（2）抽象方法
抽象方法的作用：为所有子类提供一个统一的接口。
对抽象方法只需声明，不需实现，即在声明后用一个分号（;）结束，而不需要用大括号。
声明抽象方法会造成以下三个结果：
- 如果一个类包含抽象方法，那么该类必须是抽象类。但是抽象类中不一定要含有抽象方法。
- 任何子类必须重写父类的抽象方法，若不重写，声明自身为抽象类。
- 构造方法，类方法（static修饰的方法）不能声明为抽象方法。
七、接口
（1）接口的声明
语法：
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量[public] [static][final] type name=value;
// 抽象方法
[public] [abstract] returnTypr methodName();
}例子：
interface Animal { public void eat(); public void travel(); }注意：
- 常量的定义可以缺省修饰符，系统会自动加上public，final，static属性。
- 接口中的方法都为公有的
- 接口和方法都是隐式抽象的，声明时不必加上abstract
- 接口可以继承多个接口（与类的继承不同）
（2）接口的实现
语法：
[可见度] class 类名 implements 接口名称 [,其他接口名称,...]
例子：
/* 文件名 : MammalInt.java */ public class MammalInt implements Animal{ public void eat(){ System.out.println("Mammal eats"); } public void travel(){ System.out.println("Mammal travels"); } public int noOfLegs(){ return 0; } public static void main(String args[]){ MammalInt m = new MammalInt(); m.eat(); m.travel(); } }注意：
- 接口中的所有方法都要被实现类，否则类必须声明为抽象的类。（如果实现接口的类是抽象类，那么就没必要实现该接口的方法）
- 一个类可以有多个接口，但只能继承一个类
1272
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
