面向对象 - 基本语法

特别感谢张浩同志的支持！ ^o^/

类的定义

类似于结构体，类在使用前必须先声明其属性

class haoHao{

}

该实例创建后，Java将为一个名为Zhang_Hao的haoHao类腾出一片空间。在类体中，可以存放变量和方法（类似函数），是一个相对独立的单元

class haoHao{
    String name;
    int gender = "Man";

    public void genderDeclare(){
        System.out.println("I'm a " + gender);
    }
}
// 浩浩会说他是男的，但怎么说的生理学基础不需要我们知道，方法前的public表示无论怎么对谁他都是怎么说的

如果没有加关键字static，那么在使用类的方法前，还必须要创建一个类的实例

haoHao zhangHao = new haoHao();
zhangHao.genderDeclare();
// 这一位叫张浩，是浩浩中的一位，他也会说自己是男的

而静态类只加载一次，并一直在堆中存储。因此静态类不需要创建类的实例。

static class haoHao{
    String name;
    int gender = "Man";

    public void genderDeclare(){
        System.out.println("I'm a " + gender);
    } 
}

haoHao.genderDeclare();
// 所有的浩浩都会说自己是男的

类的访问控制

为了使不同类之间能既相互联系又保持相对独立，设置合理的访问控制系统是非常有必要的。Java中对成员的访问控制分为以下四种

public

所有的类都能访问。在上面例子中，所有的类使用zhangHao.genderDeclare();方法都是可以的。

default

当成员不加任何访问控制类的关键字时，权限为default，当然加default关键字也可以。在上面例子中，class haoHao{}可以被包（类似于文件夹）中所有的成员访问，但包外不可以

package friends; // 类在friends包内

class haoHao{
    void playGame(String gameName){
        System.out.println("I want to play " + gameName + "with you");
    }
}
// 朋友能和浩浩一起玩游戏

// 另一个包
public class ruiRui{
    public static void main(String[] args){
        haoHao zhangHao = new haoHao(); // 报错
        zhangHao.playGame("Genshin");
    }
}
// 但如果不在朋友圈内，睿睿和浩浩不怎么认识，张浩不知道会是谁，自然也不能一起玩游戏

这样会报错。要想不报错，需要将包引入

import friends.*;
// 要一起玩游戏，首先要是他们的朋友

protected

受保护的成员，和default一样，类外也不能访问（例子略）

package friends;    //  类在friends包内

public class haoHao{
    protected void call(){
        System.out.println("guaguagua");
    }
}
// 浩浩会呱呱叫

import friends.*;
public class sample{
    public static void main(String[] args){
        haoHao zhangHao = new haoHao();
        son zhangSan = new son();
        zhangHao.call();    // 报错
        son.call()  // 也报错
        son.learnFather();
    }
}
// haoHao的子类
class son extends haoHao{
    call();
    void learnFather(){
        super.call();
    }
}
// 张浩儿子张三会学张浩向别人呱呱叫，但张浩不会向不是朋友的人呱呱叫

private

使用方法和public一样简单，只有类内才能访问，但类外不能访问，相当于局部变量。如果一定要获取或改变private，只能通过类内特定的方法。

public class haoHao{
    private int daoGuan = 0;
    private int answer = Integer.hashCode(daoGuan);
    private void daoGuan(){
        this.daoGuan++;
    }
    public getDaoGuanTimes(){
        return answer;
    }
}
public class sample{
    public static void main(String[] args){
        haoHao zhangHao = new haoHao();
        System.out.println(zhangHao.daoGuan);   // 报错
        System.out.println(zhanghao.getdaoGuanTimes());  // 不报错
    }
}
// 张浩导了几次只有他心里清楚，但别人不能问出真正结果，问了只会得到一串乱码

构造方法

在类中构造一个或数个（数个的情况后面会提）与类名同名的方法，这些方法叫做构造方法，可用于在类的实例的定义时实现部分操作。构造方法没有返回值，用户也不能直接调用，而只能new出来

public class haoHao{
    private int weight;
    private int height;
    public haoHao(int weight, int height){
        this.weight = weight;
        this.height = height;   // 此处的this用于指向对象中的数据，与其他数据做区别，而后面的this则比较多余
        System.out.println("wa! ~~~ a! It turns out I'm " + this.height + " high and weigh " + this.weight + " kg!");
    }
    public void getBirth(){
        System.out.println("wa! ~~~ a! It turns out I'm " + this.height + " high and weigh " + this.weight + " kg!");
    }
}
// 程序执行后，应该输出两串一样的结果
public class sample{
    public static void main(String[] args){
        haoHao zhangHao = new haoHao(3，50);
        zhangHao.getBirth();
    }
}
// 张浩一出生就能报自动报身高体重，而他也有报身高体重的能力，二者不矛盾

包

一个工程文件可以存放多个文件夹，称为包。
在包中，需要写明所在包。

package friends;    //  类的声明

public class haoHao{
    protected void call(){
        System.out.println("guaguagua");
    }
}

import friends.*;   // 包的引入，" . "后接下一级文件夹、文件、文件中的类或方法等，*表示该级下的所有成员
public class sample{
    public static void main(String[] args){
        haoHao zhangHao = new haoHao();
        son zhangSan = new son();
        son.learnFather();
    }
}
// haoHao的子类
class son extends haoHao{
    call();
    void learnFather(){
        super.call();
    }
}

在同一工程中，不适用import时，也可以这样

public class sample{
    public static void main(String[] args){
        haoHao zhangHao = new haoHao();
        son zhangSan = new son();
        son.learnFather();
    }
}
class son extends friend.haoHao{    //此处是区别
    call();
    void learnFather(){
        super.call();
    }
}

引入包的概念后，就可以一整个文件夹复制粘贴了。