JAVA基础学习-第七讲 类和对象

Tjyy
448 阅读12分钟

JAVA基础教程

学习JAVA网站 : how2j

第七讲 类和对象

7.1 引用

引用的概念，如果一个变量的类型是 类类型，而非基本类型，那么该变量又叫做引用。

public class Hero {
    String name; //姓名 
    float hp; //血量
    float armor; //护甲
    int moveSpeed; //移动速度
      
    public static void main(String[] args) {
        //使用一个引用来指向这个对象
        Hero h1 = new Hero();
        Hero h2 = h1;  //h2指向h1所指向的对象
        Hero h3 = h1;
        Hero h4 = h1;
        Hero h5 = h4;
         
        //h1,h2,h3,h4,h5 五个引用，都指向同一个对象
    }  
      
}

7.2 继承

在LOL中，武器是物品的一种，也是有名称和价格的。所以在设计类的时候，可以让武器继承物品，从而继承名称和价格属性。

  • 物品类Item

物品类Item 有属性 name,price

public class Item {
    String name;
    int price;
}
  • 武器类Weapon（不继承）

武器类： Weapon不继承Item的写法，独立设计 name和price属性，同时多了一个属性 damage 攻击力。

public class Weapon{
    String name;
    int price;
    int damage; //攻击力
 
}
  • 武器类Weapon（继承类Item）

这一次Weapon继承Item 虽然Weapon自己没有设计name和price,但是通过继承Item类，也具备了name和price属性

public class Weapon extends Item{
    int damage; //攻击力
     
    public static void main(String[] args) {
        Weapon infinityEdge = new Weapon();
        infinityEdge.damage = 65; //damage属性在类Weapon中新设计的
         
        infinityEdge.name = "无尽之刃";//name属性，是从Item中继承来的，就不需要重复设计了
        infinityEdge.price = 3600;
         
    }
     
}

7.3 方法重载

方法的重载指的是方法名一样，但是参数类型不一样

public void attack()
public void attack(Hero h1)
public void attack(Hero h1, Hero h2)
  • 可变数量的参数
// 可变数量的参数
    public void attack(Hero... heros) {
        for (int i = 0; i < heros.length; i++) {
            System.out.println(name + " 攻击了 " + heros[i].name);
 
        }
    }

7.4 构造方法

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

  • 什么是构造方法

方法名和类名一样（包括大小写），没有返回类型，实例化一个对象的时候，必然调用构造方法。

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

一旦提供了一个有参的构造方法，同时又没有显式的提供一个无参的构造方法。那么默认的无参的构造方法，就“木有了“。

  • 构造方法的重载
//带一个参数的构造方法
    public Hero(String heroname){ 
        name = heroname;
    }
     
    //带两个参数的构造方法
    public Hero(String heroname,float herohp){ 
        name = heroname;
        hp = herohp;
    }

7.5 this

this这个关键字，相当于普通话里的“我”，this即代表当前对象。

  • 通过this访问属性
//参数名和属性名一样
    //在方法体中，只能访问到参数name
    public void setName1(String name){
        name = name;
    }
     
    //为了避免setName1中的问题，参数名不得不使用其他变量名
    public void setName2(String heroName){
        name = heroName;
    }
     
    //通过this访问属性
    public void setName3(String name){
        //name代表的是参数name
        //this.name代表的是属性name
        this.name = name;
    }
  • 通过this调用其他的构造方法

如果要在一个构造方法中，调用另一个构造方法，可以使用this()

//带一个参数的构造方法
    public Hero(String name){
        System.out.println("一个参数的构造方法");
        this.name = name;
    }
      
    //带两个参数的构造方法
    public Hero(String name,float hp){
        this(name);
        System.out.println("两个参数的构造方法");
        this.hp = hp;
    }

7.6 传参

  • 基本类型传参

在方法内，无法修改方法外的基本类型参数。

//回血
    public void huixue(int xp){
        hp = hp + xp;
        //回血完毕后，血瓶=0
        xp=0;
    }
      
    public Hero(String name,float hp){
        this.name = name;
        this.hp = hp;
    }
  • 类类型传参

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

7.7 包

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

  • 把比较接近的类，规划在同一个包下

Hero,ADHero 规划在一个包，叫做charactor（角色） Item,Weapon规划在另一个包下，叫做 property(道具) 在最开始的地方声明该类所处于的包名

package charactor; //在最开始的地方声明该类所处于的包名
  • 使用其他包下的类，必须import

使用同一个包下的其他类，直接使用即可 但是要使用其他包下的类，必须import

package charactor;
//Weapon类在其他包里，使用必须进行import
import property.Weapon;
 
public class Hero {
    String name; //姓名 
    float hp; //血量 
    float armor; //护甲
    int moveSpeed; //移动速度
     
    //装备一把武器
    public void equip(Weapon w){ 
    }      
}

7.8 访问修饰符

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

  • 类之间的关系

类和类之间的关系有如下几种: 以Hero为例 自身：指的是Hero自己 同包子类：ADHero这个类是Hero的子类，并且和Hero处于同一个包下 不同包子类：Support这个类是Hero的子类，但是在另一个包下 同包类： GiantDragon 这个类和Hero是同一个包，但是彼此没有继承关系 **其他类：**Item这个类，在不同包，也没有继承关系的类

image.png

  • 不同类之间的继承关系

image.png

  • 使用修饰符的一些情况

那么什么情况该用什么修饰符呢？ 从作用域来看，public能够使用所有的情况。 但是大家在工作的时候，又不会真正全部都使用public,那么到底什么情况该用什么修饰符呢？

  1. 属性通常使用private封装起来
  2. 方法一般使用public用于被调用
  3. 会被子类继承的方法，通常使用protected
  4. package用的不多，一般新手会用package,因为还不知道有修饰符这个东西

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

7.9 类属性

当一个属性被static修饰的时候，就叫做类属性，又叫做静态属性；当一个属性被声明成类属性，那么所有的对象，都共享一个值。

  • 类属性

类属性： 又叫做静态属性 对象属性： 又叫实例属性，非静态属性 如果一个属性声明成类属性，那么所有的对象，都共享这么一个值 给英雄设置一个类属性叫做“版权" (copyright), 无论有多少个具体的英雄，所有的英雄的版权都属于 Riot Games公司。

package charactor;
public class Hero {
    public String name; //实例属性，对象属性，非静态属性
    protected float hp;
    static String copyright;//类属性,静态属性
     
    public static void main(String[] args) {
           Hero garen =  new Hero();
           garen.name = "盖伦";
            
           Hero.copyright = "版权由Riot Games公司所有";
            
           System.out.println(garen.name);
           System.out.println(garen.copyright);
            
           Hero teemo =  new Hero();
           teemo.name = "提莫";
           System.out.println(teemo.name);    
           System.out.println(teemo.copyright); 
    }  
}
  • 访问类属性

建议使用：这样更符合语义上的理解

Hero.copyright
  • 什么时候使用对象属性，什么时候使用类属性

如果一个属性，每个英雄都不一样，比如name，这样的属性就应该设计为对象属性，因为它是跟着对象走的，每个对象的name都是不同的。

如果一个属性，所有的英雄都共享，都是一样的，那么就应该设计为类属性。比如血量上限，所有的英雄的血量上限都是 9999，不会因为英雄不同，而取不同的值。 这样的属性，就适合设计为类属性。

7.10 类方法

类方法： 又叫做静态方法

对象方法： 又叫实例方法，非静态方法

访问一个对象方法，必须建立在有一个对象的前提的基础上；访问类方法，不需要对象的存在，直接就访问。

package charactor;
 
public class Hero {
    public String name;
    protected float hp;
 
    //实例方法,对象方法，非静态方法
    //必须有对象才能够调用
    public void die(){
        hp = 0;
    }
     
    //类方法，静态方法
    //通过类就可以直接调用
    public static void battleWin(){
        System.out.println("battle win");
    }
     
    public static void main(String[] args) {
           Hero garen =  new Hero();
           garen.name = "盖伦";
           //必须有一个对象才能调用
           garen.die();
        
           Hero teemo =  new Hero();
           teemo.name = "提莫";
            
           //无需对象，直接通过类调用
           Hero.battleWin();
         
    }
}
  • 调用类方法
Hero.battleWin();

建议使用第二种 类.类方法 的方式进行，这样更符合语义上的理解。

  • 什么时候设计对象方法，什么时候设计类方法

如果在某一个方法里，调用了对象属性，比如:

 public String getName(){
    	return name;
}

name属性是对象属性，只有存在一个具体对象的时候，name才有意义。 如果方法里访问了对象属性，那么这个方法，就必须设计为对象方法。

如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法，比如：

 public static void printGameDuration(){
    	System.out.println("已经玩了10分50秒");
 }

7.11 属性初始化

  • 对象属性初始化
  1. 声明该属性的时候初始化
  2. 构造方法中初始化
  3. 初始化块
package charactor;
 
public class Hero {
    public String name = "some hero"; //声明该属性的时候初始化
    protected float hp;
    float maxHP; 
    {
        maxHP = 200; //初始化块
    }  
     
    public Hero(){
        hp = 100; //构造方法中初始化
         
    }
}
  • 类属性初始化
  1. 声明该属性的时候初始化
  2. 静态初始化块
package charactor;
 
public class Hero {
    public String name;
    protected float hp;
    float maxHP;
     
    //物品栏的容量
    public static int itemCapacity=8; //声明的时候 初始化
     
    static{
        itemCapacity = 6;//静态初始化块 初始化
    }
     
    public Hero(){
         
    }
     
    public static void main(String[] args) {
        System.out.println(Hero.itemCapacity);
    }
     
}

7.12 单例模式

  • 单例模式

单例模式又叫做 Singleton模式，指的是一个类，在一个JVM里，只有一个实例存在。

  • 饿汉式单例模式

GiantDragon 应该只有一只，通过私有化其构造方法，使得外部无法通过new 得到新的实例。

GiantDragon 提供了一个public static的getInstance方法，外部调用者通过该方法获取12行定义的对象，而且每一次都是获取同一个对象。 从而达到单例的目的。

这种单例模式又叫做饿汉式单例模式，无论如何都会创建一个实例

package charactor;
 
public class GiantDragon {
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){   }
 
    //准备一个类属性，指向一个实例化对象。 因为是类属性，所以只有一个
    private static GiantDragon instance = new GiantDragon();
     
    //public static 方法，提供给调用者获取12行定义的对象
    public static GiantDragon getInstance(){
        return instance;
    }
}
  • 懒汉式单例模式

懒汉式单例模式与饿汉式单例模式不同，只有在调用getInstance的时候，才会创建实例：

package charactor;
 
public class GiantDragon {
    //私有化构造方法使得该类无法在外部通过new 进行实例化
    private GiantDragon(){       }
  
    //准备一个类属性，用于指向一个实例化对象，但是暂时指向null
    private static GiantDragon instance;
      
    //public static 方法，返回实例对象
    public static GiantDragon getInstance(){
        //第一次访问的时候，发现instance没有指向任何对象，这时实例化一个对象
        if(null==instance){
            instance = new GiantDragon();
        }
        //返回 instance指向的对象
        return instance;
    }
}
  • 什么时候使用饿汉式，什么时候使用懒汉式

饿汉式是立即加载的方式，无论是否会用到这个对象，都会加载。 如果在构造方法里写了性能消耗较大，占时较久的代码，比如建立与数据库的连接，那么就会在启动的时候感觉稍微有些卡顿。

懒汉式，是延迟加载的方式，只有使用的时候才会加载。 并且有线程安全的考量(鉴于同学们学习的进度，暂时不对线程的章节做展开)。 使用懒汉式，在启动的时候，会感觉到比饿汉式略快，因为并没有做对象的实例化。 但是在第一次调用的时候，会进行实例化操作，感觉上就略慢。

看业务需求，如果业务上允许有比较充分的启动和初始化时间，就使用饿汉式，否则就使用懒汉式。

  • 单例模式三元素 - 什么是单例模式？

回答的时候，要答到三元素

  1. 构造方法私有化
  2. 静态属性指向实例
  3. public static的 getInstance方法，返回第二步的静态属性

7.13 枚举类型

  • 预先定义的常量

枚举enum是一种特殊的类(还是类)，使用枚举可以很方便的定义常量。比如设计一个枚举类型 季节，里面有4种常量。

public enum Season {
	SPRING,SUMMER,AUTUMN,WINTER
}

public class HelloWorld {
    public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER
	}
    
    public static void main(String[] args) {
        Season season = Season.SPRING;
        switch (season) {
        case SPRING:
            System.out.println("春天");
            break;
        case SUMMER:
            System.out.println("夏天");
            break;
        case AUTUMN:
            System.out.println("秋天");
            break;
        case WINTER:
            System.out.println("冬天");
            break;
        }
    }
}
  • 遍历枚举
public class HelloWorld {
    public static void main(String[] args) {
        for (Season s : Season.values()) {
            System.out.println(s);
        }
    }
}
avatar
文章
阅读
粉丝