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