Java之面向对象特点

static关键字

被static关键字修饰的方法一般被称为静态方法 没有被static关键字修饰的方法 一般称为非静态方法。同理 被static关键字修饰的成员变量 叫静态的成员变量 ，没有被static修饰的叫非静态成员变量。

• 静态方法  只能访问静态的成员变量 如果访问非静态成员变量 那么无法通过编译，无需创建对象，使用类名就可以直接调用。
• 非静态方法 既能访问静态的成员变量，也能访问非静态的成员变量 只能通过创建对象的方式进行调用。
• 静态的成员变量和静态的方法 无需创建对象通过类名进行访问。
• 静态方法和静态成员变量 被整个程序共用 相当于共享。
• 静态区  用于存放static关键字所存储的内容

this关键字

在面向对象中，this主要代表当前类的应用，也代表着当前类的对象。(可含当前对象在堆内存中的地址)

this.构造方法

代表当前对象应用引用类中的构造函数。

this.方法  

当前引用调用类中相应的方法

代表当前类引用类中方法。

this.成员变量  

对类的成员进行初始化

代表当前对象对类成员进行初始化。

this可以当返回值使用？

返回结果相当于是本类的对象

返回当前的对象(本类new 出来得对象)
 

class Gun{
    private Clip clip;
    public Gun(){
        this(null);
    }
    public Gun(Clip clip){
        this.clip=clip;
        showGun();
    }
    public void loadClip(Clip clip){
        this.clip=clip;
        showGun();
    }
    public void shootEnemy(Player enemy){
        if(clip==null){
            System.out.println(">>>枪械没有弹夹,放了一个空枪!");
            return;
        }
        Bullet bullet=clip.popBullet();
        if(bullet==null){
            System.out.println(">>>枪械的弹夹已空,放了一个空枪!");
            return;
        }
        bullet.hitEnemy(enemy);
    }
    public void showGun(){
        if(clip!=null){
            System.out.println(">>>枪械信息:有弹夹");
        }else{
            System.out.println(">>>枪械信息:无弹夹");
        }
    }
}

instanceof 关键字

用于判断：对象是否属于后面的类型，如果属于则返回true 如果不属于则返回false

if (a instanceof Cat) {            
    System.out.println(true);            // 类型的转换             
}
else{            
    System.out.println(false);            
}

引用数据类型转换

向上转型和向下转型：强制转换和自动转换

向上转型对应着：自动转换(子类转为父类)

向下转型对应着：强制转换(父类转为子类)

满足条件：两者之间要存在继承或者是实现关系(接口)

面向对象的基本特征---继承

继承 顾名思义 ： 继承关系

父---子

父类： 被继承的类叫父类

子类： 去继承的类叫子类

类与类之间一旦出现了继承关系后，子类可以共享父类的成员变量和方法。

注：不能访问父类的私有成员变量和成员方法，若父类委定于私有化的成员变量和成员方法的话此问题忽略。

使用extends 关键字来实现类与类的继承关系

public class Animal {
    public String name;
    public int legnum;
    public void happy(){
        System.out.println("叫");
    }
}
public class Dog extends Animal{
    .....
}

 

继承关系特点：Java语言的继承关系：是一种单继承的关系

• 一个子类只能有一个父类，而一个父类可以有多个子类
• 子类可以可以使用父类的属性和方法 ，但是父类不能够访问子类独有的属性和方法
• 创建子类对象时 先执行父类的构造方法 ，然后在执行子类的构造方法
• 使用super关键字 去调用父类的构造方法
• super父类的引用 超类的引用 基类的引用 用法和this关键字类似

重写

重写发生的前提是：

两个类存在继承关系。然后子类在重写父类的方法。父-子的关系 祖--孙的关系。

形式就是：

子类重写的方法和父类方法时除了和父类方法的函数体中内容不一样外，剩下的函数部分和父类一致。

(修饰权限，函数类型，返回值类型，函数名，参数列表)

重载：

同一个类中函数重名问题

以下列子都是重载(同一个类中)
public static String add(String a,String b){
    return a+b;
}
//public static int add(int a,int b){
//    System.out.println("int+int");
//    return a+b;
//
}
public static double add(double a,double b){
    System.out.println("double+double");
    return a+b;
}
public static double add(int a,double b){
    System.out.println("int+double");
    return a+b;
}
public static double add(double a,int b){
    System.out.println("double+int");
    return a+b;
}

public static double add(int a,double b){
    return a+b;
}
public static double add(int b,double e){
    return a+b;
}

上面的这两个例子算不上重载，(和参数列表的数量和类型的排列)有关，和参数名字无关(add(int a,int b)||add(int c,int d))

（add(double a,double b)||(add(double c,double d))）等等不是重载

关于应用不明确报错

class Test1{
    public static void main(String [] args){
        int a=3;
        int b=4;
        System.out.println(add(a,b));
    }   
    public static double add(double a,double b){
        System.out.println("double+double");
        return a+b;
    }
    public static double add(int a,double b){
        System.out.println("int+double");
        return a+b;
    }
    public static double add(double a,int b){
        System.out.println("double+int");
        return a+b;
    }
}

 

此时会报错

因为此时上面三个函数虽然都重载，重名，但是int+int类型参数在三个函数中都可以运行。系统会混乱不知道调用那个函数，所以会报错。

也都因为上面三个函数的参数类型也可以兼容int,int类型。