java-类和对象

java类和对象

先看个思维导图呗
待补充。

• 定义：类就是模版，对象就是用模版创造出来的东西。

类：是一个模板，它描述一类对象的行为和状态。

对象：类的一个实例，有状态和行为。例如：一个女孩是一个对象，它的状态有：名字、性别、身高；行为有：吃、穿、学等。

下图中男孩女孩为类，而具体的每个人为该类的对象。

• 创建类和实例化对象

声明一个类要用class关键字：

//模版
class 类名称 {
    //声明成员变量
    //声明成员方法
}
//实例化：类名 对象名 = new 类名() ;

//例子
package charactor; //在最开始的地方声明该类所处于的包名,charactor（角色）
import property.Weapon;//Weapon类在其他包里，使用必须进行import
//extends继承父类Object
public class Hero extends Object{
    private int id; //private表示公共的
    float maxHP; //血量上限,没有修饰符表示package/friendly/default 
    protected float hp; //血量,protected表示受保护的 
    public String name= "some hero";; //姓名,public表示公共的//对象属性初始化
    //当一个属性被声明成类属性，那么所有的对象，都共享一个值 
    static String copyright;//类属性(静态属性),static修饰,通过类就可以直接访问

	//物品栏的容量
    public static int itemCapacity=8; //类属性初始化:声明该属性的时候初始化   
    static{
        itemCapacity = 6;//类属性初始化:静态初始化块
    }
    //无参构造方法
    public Hero(){
         
    }
    //有参构造方法
    public Hero(String name,float hp){
    	//this即代表当前对象
        this.name = name;
        this.hp = hp;
    }
    
    //方法的重载指的是方法名一样，但是参数类型不一样
	public void equip(){     
    }
    public void equip(Weapon w){
         
    }
    //类方法(静态方法),static修饰,通过类就可以直接调用
    public static void battleWin(){
        System.out.println("battle win");
    }
	
	//变量有两种类型 基本类型 和类类型 
	//基本类型传参//回血
    public void huixue(int xp){
        hp = hp + xp;
        //回血完毕后，血瓶=0
        xp=0;
    }
	//类类型传参// 攻击一个英雄，并让他掉damage点血
    public void attack(Hero hero, int damage) {
        hero.hp = hero.hp - damage;
    }
    public static void main(String[] args) {
    	//h叫引用,=表示指向(引用h，指向一个Hero对象)
        Hero h =  new Hero("提莫",383);//实例化对象，h为对象名
    }
}

注：
涉及知识：包，创建类，继承、构造方法（有参和无参） 属性（属性初始化，类属性，访问修饰符）、方法（类方法，方法重载，参数，传参），this，引用(实例化对象)

• 构造方法

1.定义：
通过一个类创建一个对象，这个过程叫做实例化。
实例化是通过调用构造方法(又叫做构造器)实现的。

2.如何创建

public class Hero {
    // 方法名和类名一样（包括大小写）
    // 没有返回类型
    public Hero() {
        System.out.println("实例化一个对象的时候，必然调用构造方法");
    }
     
    public static void main(String[] args) {
        //实例化一个对象的时候，必然调用构造方法
        Hero h = new Hero();
    }
 
}

3.隐式的构造方法

public class Hero {
    // 方法名和类名一样（包括大小写）
    // 没有返回类型
	/*这个无参的构造方法，如果不写，
    就会默认提供一个无参的构造方法
    public Hero() {
        System.out.println("实例化一个对象的时候，必然调用构造方法");
    }*/
     
    public static void main(String[] args) {
        //实例化一个对象的时候，必然调用构造方法
        Hero h = new Hero();
    }
}

4.有参的构造方法
一旦提供了有参的构造方法 ,就没有隐式的构造方法了。

public class Hero { 
    String name; //姓名
    //有参的构造方法
    //默认的无参的构造方法就失效了
    public Hero(String heroname){ 
        name = heroname;
    }
    public static void main(String[] args) {
        Hero garen =  new Hero("盖伦");  
        Hero teemo =  new Hero(); //无参的构造方法“木有了”,报错，可以自己写一个无参构造方法
    }  
      
}

5.构造方法的重载

    String name; //姓名      
    float hp; //血量
    //带一个参数的构造方法
    public Hero(String heroname){ 
        name = heroname;
    }
    //带两个参数的构造方法
    public Hero(String heroname,float herohp){ 
        name = heroname;
        hp = herohp;
    }   
}

• 访问修饰符

1.成员变量有四种修饰符
private 私有的
package/friendly/default 不写（没有修饰符即代表package/friendly/default）
protected 受保护的
public 公共的

private修饰属性 私有的
自身：是可以访问的
同包子类：不能继承
不同包子类：不能继承
同包类：不能访问
其他包类：不能访问

public class Hero {
    //属性id是private的，只有Hero自己可以访问
    //子类不能继承
    //其他类也不能访问
    private int id; 
}

package/friendly/default 不写

public class Hero {
    // 无修饰符的属性 hp
    // 自己可以访问
    // 同包子类可以继承
    // 不同包子类不能继承
    // 同包类可以访问
    // 不同包类不能访问
    float hp;
}

protected 受保护的

public class Hero {
    // protected饰符的属性 hp
    // 自己可以访问
    // 同包子类可以继承
    // 不同包子类可以继承
    // 同包类可以访问
    // 不同包类不能访问
    protected float hp;
}

public 公共的

public class Hero {
    // public的属性 name
    // 自己可以访问
    // 同包子类可以继承
    // 不同包子类可以继承
    // 同包类可以访问
    // 不同包类可以访问
    public String name;
}

总结（红色字体，表示不可行）

private：
自身 ✔ 其他都 X
package：
同包：自身，类(子类，类) ✔
不同包：其他包都 X
protected：
同包：自身，类(子类，类，不同包子类) ✔
不同包：其他包都 X
public：
同包 ✔
不同包 ✔

什么情况该用什么修饰符呢？

作用范围最小原则
简单说，能用private就用private，不行就放大一级，用package,再不行就用protected，最后用public。
这样就能把数据尽量的封装起来，没有必要露出来的，就不用露出来了。