类和对象知识点（待完善）

最新推荐文章于 2022-10-02 21:08:58 发布

Jean_ctrl

最新推荐文章于 2022-10-02 21:08:58 发布

阅读量90

点赞数

分类专栏：学习笔记初学者基础阶段文章标签： java 类

本文链接：https://blog.csdn.net/SHIFT5CTRL/article/details/116916358

版权

学习笔记同时被 3 个专栏收录

8 篇文章 0 订阅

订阅专栏

基础阶段

5 篇文章 0 订阅

订阅专栏

初学者

2 篇文章 0 订阅

订阅专栏

类和对象笔记

部分内容来自我在自学过程中的教程网站https://how2j.cn/p/8274 仅作为自己的学习笔记使用

1. 引用

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

new hero();

代表创建了一个Hero对象,但是也仅仅是创建了一个对象，没有办法访问它
为了访问这个对象，会使用引用来代表这个对象

Hero h = new Hero();

h这个变量是Hero类型，又叫做引用
=的意思指的h这个引用代表右侧创建的对象
“代表” 在面向对象里，又叫做“指向”

public class Hero {
      
    String name; //姓名
      
    float hp; //血量
      
    float armor; //护甲
      
    int moveSpeed; //移动速度
      
    public static void main(String[] args) {
        //创建一个对象
        new Hero();
         
        //使用一个引用来指向这个对象
        Hero h = new Hero();
         
    }  
      
}

重要：一个对象可以有多个引用，但是一个引用只能对应一个对象

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 五个引用，都指向同一个对象
         
    }  
      
}

 //一个引用指向多个对象
        Hero hero1 = new Hero();//对象1
        hero1 = new Hero();//对象2

注：一个引用对应多个对象，未使用时不会报错

2. 继承

设计一个物品类，包含两个属性，name price
还有一个护甲类继承物品类，有三个属性 name，price，ac

 public class JiCheng {
    public static void main(String[] args) {
        
        Arror arror1 = new Arror();
        arror1.name="布甲";
        arror1.price=300;
        arror1.ac= 15;

        Arror arror2 = new Arror();
        arror2.name="锁子甲";
        arror2.price=500;
        arror2.ac= 40;

        System.out.println("名称:"+arror1.name+"\t"+"价格:"+arror1.price+"\t"+"护甲等级:"+arror1.ac);
        System.out.println("名称:"+arror2.name+"\t"+"价格:"+arror2.price+"\t"+"护甲等级:"+arror2.ac);

    }
}
class Item{
    String name;
    int price;
}
class Arror extends Item{
     int ac;
}

运行结果如下：
继承运行结果

3. 方法重载

方法重载就是方法名一样，但是参数类型不同

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();
    }
 
}

运行结果如下：
实例化调用构造方法
注：一旦提供了一个有参的构造方法，同时又没有显式的提供一个无参的构造方法，那么默认的无参的构造方法就没有了

5. this

this关键字代表当前对象，通过this可以访问当前对象的属性（this也可以在构造函数中使用）

6. 传参

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

java值传递：当变量作为参数传递到方法内部时，过程执行的是拷贝，不论方法对形参如何修改，都不会影响实参数据。当变量为类类型时传递，实质传递的是该引用的地址，内部对形参修改影响的只是引用的地址新指向，除非修改对象.属性值，才能真正影响外部实参。

7. 包

没啥好说的，package

8. 访问修饰符

成员变量有四种修饰符
private 私有的、package/friendly/default 不写、protected 受保护的、public 公共的
比如：public float a;//表示这个变量是公共的
float a;//没有修饰符就表示是package/friendly/default
（1）类之间的关系
类和类之间的关系有如下几种:
以Hero为例
自身：指的是Hero自己
同包子类：ADHero这个类是Hero的子类，并且和Hero处于同一个包下
不同包子类：Support这个类是Hero的子类，但是在另一个包下
同包类： GiantDragon 这个类和Hero是同一个包，但是彼此没有继承关系
其他类：Item这个类，在不同包，也没有继承关系的类
（2）不同修饰符的访问范围
使用private修饰属性
自身：是可以访问的
同包子类：不能继承
不同包子类：不能继承
同包类：不能访问
其他包类：不能访问

使用package/friendly/default修饰属性
自身：是可以访问的
同包子类：能继承
不同包子类：不能继承
同包类：能访问
其他包类：不能访问

使用protected修饰属性
自身：是可以访问的
同包子类：能继承
不同包子类：能继承
同包类：能访问
其他包类：不能访问

使用public修饰属性
自身：是可以访问的
同包子类：能继承
不同包子类：能继承
同包类：能访问
其他包类：不能访问
修饰符访问范围

9. static

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

10. 类方法

又叫做静态方法，类里面有static修饰符的方法，通过类就可以调用，非静态方法，又称实例方法需要通过对象进行调用。

11. 属性初始化

声明时就初始化 1
static代码块初始化 2
构造函数初始化 3

12. 单例模式

什么是单例模式
（1）构造方法私有化
（2）静态属性指向实例
（3） public static的 getInstance方法，返回第二步的静态属性

13. 枚举类型

enum特殊的类

 public enum HeroType {
    TANK,WIZARD,ASSASSIN,ASSIST,WARRIOR,RANGED,PUSH,FARMING
}

public class Hello {
    public static void main(String[] args) {
        //使用增强for循环，遍历枚举，转换为中文输出
        for (HeroType heroType : HeroType.values()) {
            System.out.println(heroType);
            switch (heroType) {
                case TANK:
                    System.out.println("坦克");
                    break;
                case WIZARD:
                    System.out.println("法师");
                    break;
                case ASSASSIN:
                    System.out.println("刺客");
                    break;
                case ASSIST:
                    System.out.println("辅助");
                    break;
                case WARRIOR:
                    System.out.println("近战");
                    break;
                case RANGED:
                    System.out.println("远程");
                    break;
                case PUSH:
                    System.out.println("推进");
                    break;
                case FARMING:
                    System.out.println("打野");
                    break;
            }
        }

    }
}