类的声明、调用

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();

	}
}

需求 ： 编写一个驾驶汽车的方法 。

面向过程：　编写一个方法　drivecar() ;

面向对象： 将CAR看作一个对象 ，将CAR的共性抽取出来 ，设计一个CAR类，类中定义一个方法drive();,调用CAR.drive() ，实现需求 。


* 类的构造方法 ：

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();

	}
}

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 ：
条件 ：方法的名称相同，但参数类型或者参数个数不同，才能构成方法的重载。

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();

	}
}

特殊变量 this ：
1，this变量代表对象本身。
2，当类中有两个同名变量，一个属于类的成员变量 ，一个属于方法里面的局部变量 ，使用this区分成员变量和局部变量。
3，使用this简化构造函数的调用。

实例方法和实例数据成员的说明 ：
1，一个类所有的实例对象调用的成员方法在内存中只有一份拷贝，尽管在内存中有可能有多个对象，
而数据成员在类的每个对象所在的内存中都存在一份拷贝。
2.this对象允许相同的实例方法为不同的对象工作。

当调用static静态方法时，可以直接调用类名.方法 ：

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(); //直接调用

	}
}

关键字 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（），如果父类没有这种形式的构造方法 ，那么在编译的时候就会据报错 。

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();
	}
}

多态性 ：
通过覆盖父类的方法来实现 ，在运行时根据传递对象的引用 ，来调用相应的方法 。

例 ：
需求 ： 求长方形的周长和面积
1，面向过程的方法

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));
	}
}

2，面向对象的方法

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());
	}
}

方法的使用控制 ：
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，抽象类不能实例化对象 。

native方法 ：
1，native是用户在Java中可以使用，但不能编写的方法 。
2，JNI（Java native Inteface）它运行JVM运行的Java代码能够与其他编程语言编写的应用程序和库进行互操作 。
3，JNI最大的好处就是它没有对底层java虚拟机的实现实施加任何限制，
因此 ，程序员只要编写一种版本的本地native应用程序和库就可以与所有支持JNI的Java虚拟机协同工作 。
4，JNI可以理解为Java和本地应用程序之间的中介 。

垃圾回收 ：

public class Garbage
{
	int index ;
	int count ;
	Garbage()
	{
		count++ ;
		System.out.println(count);
		setID(count);
	}
	void setID(int id)
	{
		index = id ;
	}
	protected void finalize()
	{
		System.out.println("relaimed"+index);
	}
	public static void main(String[] args)
	{
		new Garbage();
		new Garbage();
		new Garbage();
		new Garbage();
		System.gc(); //显示垃圾回收 
	}
}

接口 ：
1，在接口中所有方法都应该是 public abstract 。。。。
2，接口更重要的作用是制定模块与模块之间的通信的协议 。

interface SportDemo
{
	void run();
	void jump();
}
class Sporter implements SportDemo
{
	public void run()
	{
		System.out.println("run");
	}
	public void jump()
	{
		System.out.println("jump");
	}
	public static void main (String[] args)
	{
		Sporter zhangsan = new Sporter();
		zhangsan.run();
		zhangsan.jump();
	}
}