java OOP

本WORD附下载 对象知识点.rar

 

 

面向对象求长方形的周长和面积

 

 

 

 

 

面向过程求长方形的周长和面积

 

 

 

 

 

 

对象一般都有两个特征：状态和行为

类实质上定义的是一种数据类型，这种数据类型就是对象类型。所以
我们可以使用类名称来声明对象变量



类实例化：


public class Point {

    /**
     * @param args
     */
    int x;
    int y;
    void output()
    {
        System.out.println(x);
        System.out.println(y);
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Point pt;
        pt = new Point();
        pt.x = 10;
        pt.y = 10;
        pt.output();
    }

}





思路的转变：
我们通常习惯于考虑解决问题的方法，而不是考虑将问题抽象成对象再去解决它。

函数可以用修饰字符么？―――　一般什么都不用

类中　This.变量　和　变量　有没有使用上的区别？
-----区别类中的全局变量和同名的局部变量  this.x = x;

――this还可以简化构造函数的调用：必须在函数体的第一行

public class Point {

    int x;
    int y;
    Point()
    {
        this(1,1);//必须在函数体的第一行
    }
    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();
        pt.output();
       
    }

}






方法的重载overload：方法的名称相同，但参数类型或个数不同，才能构成方法的重载
多个构造方法：


public class Point {

    int x;
    int y;
    Point()
    {
        x=5;
        y=5;
    }
    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();
        pt.output();
       
        Point pt2;
        pt2 = new Point(6,6);
        pt2.output();
       
    }

}


new 关键字的作用
１　为对象分配内存空间
２　引起对象构造方法的调用
３　为对象返回一个引用




一个类所有的实例调用的成员方法在内存中只有一份拷贝
pt.output()
pt2.output()
output方法只有一份拷贝，而实例成员可以存在多个拷贝



static方法，可以直接使用　类名.static方法　调用
在静态方法中不能调用非静态的方法和引用非静态的成员变量。反之，则可以。
public class Point {

    int x;
    static void output()
    {
        System.out.println("333");
    }
    public static void main(String[] args) {
        Point.output();
       
    }

}

静态方法只属于类本省，不属于对象，静态方法也叫类方法，非静态方法叫做实例方法。
如果改动一下：
static void output()
    {
        System.out.println(x);
    }
这样会报错，因为直接使用类名.static方法调用是没有生成对象的，没有对象那么也就没有对象成员x.的内存空间【内存模型概念，没有内存空间都是不能被调用的】。如果一定要输出x，那么就要声明为静态变量，类变量。

public class Point {

    static int x = 3;
    static void output()
    {
        System.out.println(x);
    }
    public static void main(String[] args) {
        Point.output();
       
    }

}


静态成员：

public class Point {
    static int x;
    public static void main(String[] args) {
        Point pt = new Point();
        Point pt2 = new Point();
        pt.x=1;
        pt2.x=2;
        System.out.println(pt.x);
        System.out.println(pt2.x);
//两个对象共享同一个静态变量，静态变量属于类本身，而不是属于对象
    }
}






常量：通常大写，并推荐声明为静态。值不能被修改.声明的时候要初始化，也可以在构造函数中初始化。但是当声明是静态的常量，那么一定必须在声明的时候初始化，直接使用类名.类变量来访问的时候常量没有被赋值就是错误的。
final double PI = 3.1415926;


Extends  继承
Java不也许多继承，即是一个类不也许同时继承多个类

方法的覆盖：在子类中定义一个与父类同名，返回类型，参数类型均相同的一个方法。


当实例化子类的时候，父类的构造方法先与子类的构造方法被调用
class Person
{
    int height;
    Person()
    {
        System.out.println("Person construct");
    }
}

class Fish extends Person
{
    int height;
    Fish()
    {
        System.out.println("Fish construct");
    }
}

class Animal
{
    Animal()
    {
       
    }
    public static void main(String[] args) {
        Fish fh = new Fish();
       
    }
   
}



构造方法不能被继承

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


class Person
{
    int height;
    Person()
    {
        System.out.println("Person construct");
    }
    void breathe()
    {
        System.out.println("Person breathe");
    }
}

class Fish extends Person
{
    int height;
    Fish()
    {
        System.out.println("Fish construct");
    }
    void breathe()
    {
        System.out.println("Fish breathe");
    }
}

class Animal
{
    Animal()
    {
       
    }
    static void fn(Person ps)//对象引用的传递,原本传递的父类，但是可以被子类替换
    {
        ps.breathe();
    }
    public static void main(String[] args) {
        Fish fh = new Fish();
        Person ps;
        ps = fh;
        Animal.fn(ps);
       
    }
   
}

/*
Person construct
Fish construct
Fish breathe
*/


判断一个对象是否是××的实例instanceof
if(an instanceof Animal)
{
   
}

子类也是父类的实例




Package 主要是避免类名相同的麻烦。Java文件中package 必须位于第一行
Javac –d . Test.java    -d可以自动生成package所对应的目录层次 .表示当前目录，也可以指定目录　javac –d d:\test Test.java

Java com.Test

Import java.io.File;
Import java.io.*;
在同一个包中的类可以相互引用，无需import语句
如果不import,可以这样申明对象f：java.io.File f;

批量编译javac –d . *.java


类的修饰符　　
类的访问说明符：public default    控制别的包，类引用
public 可以被不同包引用，java内置的包都是public
default 只能被同包中的类引用

其它修饰符：final abstract
final　最终的包，不能再派生  java.lang.string 就是final
abstract 　抽象类，配合抽象方法。抽象类不能被实例化。子类要实现父抽象类的所有抽象方法，否则这个子类也要声明为抽象类。我们可以将一个没有任何抽象方法的类声明为抽象类，避免由这个类产生任何的对象。


有的可以同时使用：
public final class Test
public abstract calssTest





接口：所有的方法都是抽象方法

 

方法的修饰符

方法的访问说明符： public(java 内置的方法都是 public) protected default （只能在同包中访问） private( 卧室概念，只能在同类中所访问 )

 

 

 

 

 

 

 

 

 

protected 　的通用性不能被使用是怎样的情况 ---- 不同的包只有是父子类的关系才能被访问，不是父子类关系的不同包是不能访问的。也就是有父子关系的类可以使用

 

其它修饰符： static final abstract native synchronized

final 不能被覆盖的类， private 或 static 修饰的方法都是　 final ，子类中重写 static 方法，只是生成了另一个 static 方法，并没有覆盖父类中的 static

abstract   写法： protected abstract void test(); 　有抽象方法的类必须声明为抽象类。抽象类不能被实例化。子类要实现父抽象类的所有方法，否则这个子类也要声明为抽象类

 

 

 

 

接口 interface

class ** （类） implements （实现） ** （接口）

interface ** （接口） extends （继承） ** （接口）

接口的派生类必须实现接口里所有的方法，否值必须把该类声明为抽象类

派生类的方法一律不得低于 public

接口中的所有的方法都是 public abstract ，不能对接口中的方法使用其它修饰符

接口中的成员变量默认为 public static final

接口类一般声明为 public

java 中允许接口的多继承，不允许其它类的多继承

允许一个类实现多个接口，一个类在继承的同时可以实现多个接口。

 

 

 

 

 

 

 

 

 

 

 

 

如何返回接口的成员

 

 

 

 

 

接口实例：电脑主板显卡

 

 

 

 

 

 

 

 

内部类
内部类编译后的文件名为：Outer$Inner.class

Outer.java
class Outer {
    private int index=100;
    class Inner
    {
        void print()
        {
            System.out.println(index);//内部类可以外部的访问private 的成员变量
        }
       
    }
    void print()
    {
        Inner inner=new Inner();
        inner.print();
    }
       
}

Test.java
class Test {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.print();
    }

}

 

 

 

 

 

 

内部类可以随意访问外部类的所有成员变量和方法。


访问外部类和内部类的成员变量
Outer.java
class Outer {
    private int index=100;
    class Inner
    {
        private int index=50;
        void print()
        {
            int index=30;
            System.out.println(index);//30
            System.out.println(this.index);//50
            System.out.println(Outer.this.index);//100
        }
       
    }
    void print()
    {
        Inner inner=new Inner();
        inner.print();
    }
       
}


Test.java
class Test {
    public static void main(String[] args) {
        Outer outer=new Outer();
        outer.print();
    }

}




实例内部类
Outer.java
class Outer {
    private int index=100;
    class Inner
    {
        private int index=50;
        void print()
        {
            int index=30;
            System.out.println(index);
            System.out.println(this.index);
            System.out.println(Outer.this.index);
        }
       
    }
    void print()
    {
        Inner inner=new Inner();
        inner.print();
    }
    Inner getInner()//返回值是对象
    {
        return new Inner();
    }
       
}

Test.java
class Test {
    public static void main(String[] args) {
        Outer outer=new Outer();
        Outer.Inner inner=outer.getInner();//不能直接访问内部类，Inner inner=outer.getInner();是错误的写法，必须加上它的前缀外部类
        inner.print();
    }

}





Outer.Inner inner=out.new Inner();　　这样的方式也可以实例化内部类