[code="java"]public class Point {
int x , y ;
void output(){
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args){
Point pt;
pt = new Point();
pt.x = 10 ;
pt.y = 20 ;
pt.output();
}
}[/code]
需求 ： 编写一个驾驶汽车的方法 。
面向过程： 编写一个方法 drivecar() ;
面向对象： 将CAR看作一个对象 ，将CAR的共性抽取出来 ，设计一个CAR类，类中定义一个方法drive();,调用CAR.drive() ，实现需求 。
* 类的构造方法 ：
[code="java"]public class Point {
int x , y ;
Point(int a ,int b){ //构造方法 ：构造方法的名称和类名是一样的 ，没有返回值。
x=a;
y=b;
}
void output(){
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args){
Point pt;
pt = new Point(3,5);//在这里传参
//pt.x = 10 ;
//pt.y = 20 ;
pt.output();
}
}[/code]
1，构造方法的名字和类名一样，并且没有返回值。
2，构造方法只要用于类的对象定义初始化状态。
3，不能直接调用构造方法 ，必须new关键字，创建类的实例。
4，java类都要求有构造方法 ，如果没有定义构造方法，java编译器会自动为我们添加一个缺省的构造方法。
5，javap.exe---->反编译工具
new 关键字的理解
1，为对象分配内存空间。
2，引起对象构造方法的调用。
3，为对象返回一个引用 。
各种数据类型的默认值 ：
1，数值型 0
2，boolean false
3，char '\0'
4,对象 null
方法的重载 overload ：
条件 ：方法的名称相同，但参数类型或者参数个数不同，才能构成方法的重载。
[code="java"]
public class Point {
int x , y ;
Point(int a ,int b){ //构造方法 ：构造方法的名称和类名是一样的 ，没有返回值。
x=a;
y=b;
}
Point(){
}
void output(){
System.out.println(x);
System.out.println(y);
}
public static void main(String[] args){
Point pt;
pt = new Point(3,5);//这样会调用带有参数的构造方法
pt = new Point();//这样会调用缺省无参的构造方法
//pt.x = 10 ;
//pt.y = 20 ;
pt.output();
}
}[/code]
特殊变量 this ：
1，this变量代表对象本身。
2，当类中有两个同名变量，一个属于类的成员变量 ，一个属于方法里面的局部变量 ，使用this区分成员变量和局部变量。
3，使用this简化构造函数的调用。
实例方法和实例数据成员的说明 ：
1，一个类所有的实例对象调用的成员方法在内存中只有一份拷贝，尽管在内存中有可能有多个对象，
而数据成员在类的每个对象所在的内存中都存在一份拷贝。
2.this对象允许相同的实例方法为不同的对象工作。
当调用static静态方法时，可以直接调用类名.方法 ：
[code="java"]public class Point {
int x , y ;
Point(int a ,int b){ x=a;
y=b;
}
static void output(){
System.out.println("静态方法");
}
public static void main(String[] args){
// Point pt;
// pt = new Point(3,5);//在这里传参
// pt.x = 10 ;
// pt.y = 20 ;
// pt.output();
Point.output(); //直接调用
}
}[/code]
关键字 static ：
1，静态方法只属于类的本身 ，称为类的方法 ，非静态方法可称为实例方法。
2，静态方法和静态变量是属于同一个类，而不属于类的对象。
3，静态方法和静态变量可以直接通过类名引用 。
4，在静态方法中不能访问非静态非静态方法和引用非静态成员，反之可以。
5，可以用类的对象obj去调用静态的方法method()，如obj.method().
常量的定义 ：
1，例如 ： static final double PI = 3.1415926 ；
2，作为一种约定 ，在定义常量时 ，一般采用大写形式 。
3，final常量可以在声明的同时赋予初值 ，也可以在构造函数中赋予初值。
4，为了节省内存 ，我们通常将常量声明为static 。
类的继承 ：
被继承的类称为超类（父类、基类） ，继承的类称为子类（派生类） 。java中不允许多继承。
方法的覆盖 ： override
在子类中定义一个与父类同名，返回类型，参数类型均相同的一个方法 ，称为方法的覆盖 。覆盖发生在子类与父类之间 。
特殊变量super ：
1，特殊变量super提供了对父类的访问。
2，可以使用super访问父类被子类隐藏的变量或覆盖的方法 。
3，每个子类构造方法的第一条语句，都是隐含的调用super（），如果父类没有这种形式的构造方法 ，那么在编译的时候就会据报错 。
[code="java"]
class Animal{
int height , weight ;
void eat(){
System.out.println("animal eat");
}
void sleep(){
System.out.println("animal sleep");
}
void breathe(){
System.out.println("animal breathe");
}
}
class Fish extends Animal{
void breathe(){
super.breathe();//子类调用父类的方法 。
System.out.println("fish breathe");
}
}
class Integration{
public static void main(String[]aargs){
Animal an = new Animal();
Fish fh = new Fish();
an.breathe();
fh.height= 22;
fh.breathe();
}
}
[/code]
多态性 ：
通过覆盖父类的方法来实现 ，在运行时根据传递对象的引用 ，来调用相应的方法 。
例 ：
需求 ： 求长方形的周长和面积
1，面向过程的方法
[code="java"]class Rectangle{
static int perimeter(int length ,int width)
{
return 2*(length+width);
}
static int area(int length,int width)
{
return length*width ;
}
public static void main(String[] args)
{
System.out.println(Rectangle.perimeter(2, 3));
System.out.println(Rectangle.area(3,5));
}
}[/code]
2，面向对象的方法
[code="java"]class Rectangle
{
int l ,w ;
int perimeter()
{
return 2*(l+w) ;
}
int area()
{
return l*w ;
}
public static void main(String[] args)
{
Rectangle rect1 = new Rectangle();
Rectangle rect2 = new Rectangle();
rect1.l = 10 ;
rect1.w = 91;
rect2.l = 2 ;
rect2.w = 3 ;
System.out.println(rect1.perimeter());
System.out.println(rect1.area());
System.out.println(rect2.perimeter());
System.out.println(rect2.area());
}
}[/code]
方法的使用控制 ：
public protected default private
同类 1 1 1 1
同包 1 1 1
子类 1 1
通用性 1
final 方法 ：
1，为了确保某个函数行为在继承过程中保持不变，并且不能被覆盖，可以使用final方法。
2，为了效率上的考虑，将方法声明为final ，让编译器对此方法的调用进行优化，更注意的是 ： 编译器会自行对final方法进行判断，并决定是否进行优化，通常在方法的体积很小，而我们确实不希望覆盖它时，才将他声明为final 。
3，class中的private和static方法自然就是final 。
抽象方法和抽象类：
1，在类中没有方法的方法就是抽象方法 。
2，还有抽象方法的类 ，即为抽象类 。
3，如果一个子类没有实现基类方法中所有抽象方法 ，则子类也为一个抽象类 。
4，我们可以将一个没有任何抽象方法的类声明为abstract ，避免这个类产生任何的对象 。
5，抽象类不能实例化对象 。