Java Day07

传参10.26

说明：变量有两种类型 基本类型和类类型，参数也是变量所以传参分为基本类型传参，类类型传参

基本类型传参

/*基本类型传参
方法内，无法修改方法外的基本类型参数
*/
package bese;

public class Hero {

    String name; //姓名

    float hp; //血量

    float armor; //护甲

    int moveSpeed; //移动速度
    public Hero(){
    }
    public void huixue(int xp){
        hp = hp + xp;   //回血完毕后，血瓶为0
        xp = 0;
    }
    public Hero(String name,float hp){
        this.name = name;
        this.hp = hp;
    }

    public static void main(String[] args) {
        Hero teemo = new Hero("提莫",383);
        int xueping = 100;  //给血瓶的值为100
        teemo.huixue(xueping);  //通过血瓶进行回血
        System.out.println(xueping);
    }
}

引用与=

/*
变量是基本类型，int hp = 50;
hp叫变量 =表示赋值的意思
一个变量是类类型
Hero h = new Hero();
h叫做引用，h不再是赋值的意思，而是指向的意思
Hero h = new Hero();
可理解为引用h，指向了一个Hero对象
*/

类类型传参

说明：类类型又叫引用
第24行的引用 teemo与 第17行的引用hero，是不同的引用
通过调用garen.attack(teemo, 100); 使得这两个引用都指向了同一个对象
所以在第18行hero.hp = hero.hp - damage; 就使得该对象的hp值，发生了变化
因此第25行，打印该对象的Hp值就是变化后的值

public class Hero {
 
    String name; // 姓名
 
    float hp; // 血量
 
    float armor; // 护甲
 
    int moveSpeed; // 移动速度
 
    public Hero(String name, float hp) {
        this.name = name;
        this.hp = hp;
    }
 
    // 攻击一个英雄，并让他掉damage点血
    public void attack(Hero hero, int damage) {
        hero.hp = hero.hp - damage;
    }
 
    public static void main(String[] args) {
        Hero teemo = new Hero("提莫", 383);
        Hero garen = new Hero("盖伦", 616);
        garen.attack(teemo, 100);
        System.out.println(teemo.hp);
    }
 
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qCE7HDO8-1635587787889)(X:\Users\Administrator.DESKTOP-HQEE7OG\AppData\Roaming\Typora\typora-user-images\image-20211027175841044.png)]

包

说明：包package，把比较接近的类，规划在同一个包下

如下方Hero规划在了charactor（角色）包中

Item和Weapon规划在了property（道具）包中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-331DfEna-1635587787891)(X:\Users\Administrator.DESKTOP-HQEE7OG\AppData\Roaming\Typora\typora-user-images\image-20211029101554599.png)]

package bese;   //最开始的地方说明该类所处在的包名
import bese.charactor.Hero; //bese.charactor 中的bese是上级文件名称 charactor是刚才新增的包
//当引用Hero出现错误提示时，需要import指明Hero的位置（在哪个包下面）

public class Demo02 {
    public static void main(String[] args) {
        Hero h1 = new Hero();	//使用其它包下的类，必须import，如第二行显示，同一包下的其它类，直接使用就可以
        //还有一种就是系统自带的基础类，就已经默认import了，不需要单独指出
        h1 = new Hero();
    }
}

访问修改符

说明：成员变量有4种修饰符

• private 私有的
• package/friendly/default 不写
• public 公共的

类之间的关系

说明：类之间的关系有以下几种：以Hero为例

• 自身：指Hero自己
• 同包子类：ADHero该类是Hero的子类（ADHero在Hero下），并与Hero在同一包下
• 不同包子类：Support是Hero的子类，但在另外一个包下
• 同包类：GiantDragon和Hero处于同包类，但彼此没有继承关系
• 其他类：Item这个类，在不同包，也没哟任何的继承关系
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GpX3fdgg-1635587787893)(X:\Users\Administrator.DESKTOP-HQEE7OG\AppData\Roaming\Typora\typora-user-images\image-20211029104314125.png)]

private私有

说明：private修饰符属性

• 自身：可以访问

• 同包子类：不能继承

• 不同包子类：不能继承

• 同包类：不能访问

• 其他同包类：不能访问

• 	自身	同包子类	不同包子类	同包类	其他类
  private	访问√	继承×	继承×	访问√	访问×

package bese;

import bese.property.Weapon;

public class Hero {
    private int id; //属性id是private，只有Hero自己能访问
    //子类不能访问，其它类也不能访问
    String name;
    float hp;
    float armor;
    int moveSpeed;
    public void equip(Weapon w){
        
    }
}

package/friendly/default 不写

说明：没有修饰符即代表package/friendly/default

如float maxHP;血量上限

	自身	同包子类	不同包子类	同包类	其他类
package	访问√	继承√	继承×	访问√	访问×

package bese;

import bese.property.Weapon;

public class Hero {
    private int id; 
    String name;
    /*
    无修饰符的属性 hp
    自己可以访问
    同包子类可以继承
    不同包子类不能继承
    同包类可以访问
    不同包类不能访问
     */
    float hp;
    float armor;
    int moveSpeed;
    
    public void equip(Weapon w){
    }
}

protected 受保护的

说明：受保护的修饰符 protected float hp; 血量

	自身	同包子类	不同包子类	同包类	其他类
protected	访问√	继承√	继承√	访问√	访问×

package bese;
import bese.property.Weapon;

public class Hero{
    private int id;
    String name;
    
   protected float hp; 	//protected属性 如上访问权限
    float armor;
    int moveSpeed;
    public void equip(Weapon w){
    }
}

public 公共的

说明：public 公共的修饰符 public String name;姓名 任何地方都可以访问

	自身	同包子类	不同包子类	同包类	其他类
public	访问√	继承√	继承√	访问√	访问√

总结（类之间的关系）

	自身	同包子类	不同包子类	同包类	其他类
private	访问√	继承×	继承×	访问×	访问×
package	访问√	继承√	继承×	访问√	访问×
protected	访问√	继承√	继承√	访问√	访问×
public	访问√	继承√	继承√	访问√	访问×

q 问题：修饰符的选用，如何合理选择？

a 从作用域来看，public能够使用所有的情况，但实际使用中，不会全部都使用public

修饰符的选用条件：

1. 属性通常使用private封装起来
2. 方法一般使用public用于被调用
3. 会被子类继承的方法，通常使用protected
4. package使用频率不高，一般新手用package

原则性：作用范围最小原则使用，能用private就用private，不能才使用上一级，这样才能尽量的把数据封装起来，才不会漏出