Java04-类和对象

最新推荐文章于 2023-11-05 21:54:29 发布
最新推荐文章于 2023-11-05 21:54:29 发布
阅读量352 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40893824/article/details/109048156
版权

https://www.nowcoder.com/tutorial/94/ae05554a3ad84e42b6f9fc4d52859dc4

https://how2j.cn/k/class-object/class-object-class-attribute/296.html#nowhere

目录

Object类

Object类是所有类的父类

其常用方法：
对象名.toString 返回类的字符串形式，需要自己重写，否则返回的是对象的地址
boolean i = 对象名1.equals(对象名2) 两对象是否一样，而不是单值是否相等
Class 对象名.getClass() 返回对象所属类
对象名.hashCode()：返回其所在对象的物理地址（哈希码值)

1 引用

变量类型是 类，该变量叫 “引用”
java 默认会有无参构造

package 第1个程序.引用;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public static void main(String[] args) {
        // 创建1个对象
        new Hero();

        // 引用h 指向这个对象
        Hero h = new Hero();
    }
}

1.1 多引用，1个对象

package 第1个程序.引用;

//多引用，1个对象
public class Hero1 {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public static void main(String[] args) {
        Hero1 h1 = new Hero1();
        Hero1 h2 = h1;
        Hero1 h3 = h1;
        Hero1 h4 = h1;
        Hero1 h5 = h1;       
    }
}

1.2 单引用，多对象

package 第1个程序.引用;

//单引用，多对象
public class Hero2 {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public static void main(String[] args) {
        Hero2 h1 = new Hero2();
        h1 = new Hero2();
    }
}

此时，h1 仅指向1个对象，就没指向第1个对象了！

2 继承

不能从别的包中继承类。。。

可以用 import 解决
import 第1个程序.a2_引用.Hero;

package 第1个程序.a3_继承;

// 物品
public class Item {
    String name;
    int price;
}

package 第1个程序.a3_继承;

public class Weapon extends Item{
    int damage; // 攻击力

    public static void main(String[] args) {
        Weapon w1 = new Weapon();
        w1.name = "无尽之刃";
        w1.price = 3600;
        w1.damage = 65;
    }
}

设计1个类 Armor (护甲类)
继承 Item，提供属性 ac (int): 护甲值

实例化 2 件护甲
名称 价格 护甲等级
布甲 200 15
锁子甲 500 40

package 第1个程序.a3_继承;

public class Armor extends Item{
    int ac; //护甲值

    public static void main(String[] args) {
        Armor a1 = new Armor();
        a1.name = "布甲";
        a1.price = 200;
        a1.ac = 15;

        Armor a2 = new Armor();
        a2.name = "锁子甲";
        a2.price = 800;
        a2.ac = 40;
    }
}

3 重载

重载：方法名一样，参数类型不同

package 第1个程序.a3_重载;

public class ADHero extends Hero {
    public void attack(){
        System.out.println(name + "进行了1次攻击，但不确定打中了谁");
    }

    public void attack(Hero h1){
        System.out.println(name + "对 " + h1.name + "进行了1次攻击");
    }

    public void attack(Hero h1, Hero h2){
        System.out.println(name + "对 " + h1.name + "和" + h2.name + "进行了1次攻击");
    }

    public static void main(String[] args) {
        ADHero h = new ADHero();
        h.name = "赏金猎人";

        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫";

        h.attack(h1);
        h.attack(h1,h2);
    }
}

3.1 参数可变

    public void attack(Hero... heroes){
        for(int i = 0; i < heroes.length ; i++){
            System.out.println(name + "对 " + heroes[i].name + "进行了1次攻击");
        }
    }

3.2 练习

设计类Support (辅助英雄)继承Hero
提供 heal(治疗)方法
heal方法可重载：
heal()
heal(Hero h) //为指定的英雄加血
heal(Hero h, int hp) //为指定的英雄加了hp的血

package 第1个程序.a3_重载;

public class Support extends Hero{
    public void heal(){
        System.out.println(name + "不知对谁奶了一口");
    }

    public void heal(Hero h1){
        System.out.println(name + "奶了一口" + h1.name);
    }

    public void heal(Hero h1, float hp){
        System.out.println(name + "奶了一口" + h1.name + ",加血" + hp);
    }

    public static void main(String[] args) {
        Support support = new Support();
        support.name = "辅助";

        Hero h1 = new Hero();
        h1.name = "盖伦";
        Hero h2 = new Hero();
        h2.name = "提莫";

        support.heal();
        support.heal(h1);
        support.heal(h1,100);
    }
}

4 this super

小明说：“我吃了” ，“我” 是小明
小红说：“我吃了” ，“我” 是小红
"我"代表当前人物

this = “我”
this 代表当前对象

super 其父类对象

this 仅在构造函数中能用

package 第1个程序.a4_this;

public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public void show(){
        System.out.println("该 this虚拟地址 = " + this);
    }

    public static void main(String[] args) {
        Hero h1 = new Hero();
        h1.name = "盖伦";
        System.out.println("打印看到的对象虚拟地址 = " + h1);
        h1.show();
        System.out.println();

        Hero h2 = new Hero();
        h2.name = "提莫";
        System.out.println("打印看到的对象虚拟地址 = " + h2);
        h2.show();
    }
}

4.1 赋值

package 第1个程序.a4_this;

public class Hero2 {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public void setName(String heroname){
        name = heroname;
    }
    
    public void setName2(String name){
        this.name = name;
    }

    public static void main(String[] args) {
        Hero2 h1 = new Hero2();
        h1.setName("盖伦");
        System.out.println(h1.name);

        Hero2 h2 = new Hero2();
        h2.setName("提莫");
        System.out.println(h2.name);
    }
}

4.2 调用方法

package 第1个程序.a4_this;

// this调用方法
public class Hero3 {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero3(String name){
        System.out.println("1个参数的构造方法");
        this.name = name;
    }

    public Hero3(String name, float hp){
        this(name);
        System.out.println("2参数的构造方法");
        this.hp = hp;
    }

    public static void main(String[] args) {
        Hero3 h1 = new Hero3("盖伦",72);
        System.out.println(h1.name + " " + h1.hp);

        Hero3 h2 = new Hero3("提莫",35);
        System.out.println(h2.name + " " + h2.hp);
    }
}

4.3 练习

设计构造方法，参数名称分别是
String name
float hp
float armor
int moveSpeed

package 第1个程序.a4_this;

// this调用方法
public class Hero4 {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero4(String name, float hp){
        this.name = name;
        this.hp = hp;
    }

    public Hero4(String name, float hp, float armor, int moveSprrd){
        this(name,hp);
        this.armor = armor;
        this.moveSprrd = moveSprrd;
    }

    public static void main(String[] args) {
        Hero4 h1 = new Hero4("盖伦",900);
        System.out.println(h1.name + " " + h1.hp);

        Hero4 h2 = new Hero4("提莫",800,35,130);
        System.out.println(h2.name + " " + h2.hp + " " + h2.armor + " " + h2.moveSprrd);
    }
}

5 传参

基本类型(不写了)
引用：Hero h = new Hero();
类类型

package 第1个程序.传参;

// 类作为形参
public class Hero {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero(String name, float hp){
        this.name = name;
        this.hp = hp;
    }

    public void attack(Hero hero, float damage){
        hero.hp -= damage;
        System.out.println(hero.name + "被砍" + damage + ",还剩" + hero.hp);
    }

    public static void main(String[] args) {
        Hero h1 = new Hero("盖伦", 900);
        Hero h2 = new Hero("提莫",700);
        h1.attack(h2,300);
    }
}


package 第1个程序.传参;

// 类作为形参
public class Hero1 {
    String name;
    float hp; //血量
    float armor; //护甲
    int moveSprrd; //速度

    public Hero1(String name, float hp){
        this.name = name;
        this.hp = hp;
    }

    public void attack(Hero1 hero, float damage){
        hero.hp -= damage;
        System.out.println(hero.name + "被砍" + damage + ",还剩" + hero.hp);
    }

    public void revive(Hero1 hero){
        hero.hp = 700;
        System.out.println(hero.name + "已复活！");
    }

    public static void main(String[] args) {
        Hero1 h1 = new Hero1("盖伦", 900);
        Hero1 h2 = new Hero1("提莫",700);
        h1.attack(h2,10000);
        if(h2.hp<0){
            h2.revive(h2);
            System.out.println("血量：" + h2.hp);
        }
    }
}

6 访问修饰


红字表示不可行

7 类属性 static

public class Hero {
    public String name; //实例属性，对象属性，非静态属性
    protected float hp;
    public static String copyright;//类属性,静态属性
}

public String name; // 实例属性 = 对象属性 = 非静态属性
static String copyright; // 类属性 = 静态属性
1个属性，所有对象都共享，是一样的，就该是类属性

package 第1个程序.类属性;

public class Hero {
    public String name; //姓名
    protected float hp; //血量
    static String copyright; //版权

    public Hero(String name, float hp){
        this.name = name;
        this.hp = hp;
    }

    public void print(Hero hero){
        System.out.println(hero.name + ", 血量：" + hero.hp + "版权：" + hero.copyright);
    }

    public static void main(String[] args) {
        Hero h1 = new Hero("盖伦",800);
        Hero.copyright = "腾讯专有";
        h1.print(h1);

        Hero h2 = new Hero("提莫", 500);
        h2.print(h2);

    }
}

7.1 修改

package 第1个程序.类属性;

public class Hero {
    public String name; //姓名
    protected float hp; //血量
    static String copyright; //版权

    public Hero(String name, float hp){
        this.name = name;
        this.hp = hp;
    }

    public void print(Hero hero){
        System.out.println(hero.name + ", 血量：" + hero.hp + "版权：" + hero.copyright);
    }

    public static void main(String[] args) {
        Hero h1 = new Hero("盖伦",800);
        Hero.copyright = "腾讯专有";
        h1.print(h1);

        Hero h2 = new Hero("提莫", 500);
        h2.print(h2);
        h2.copyright = "123";
        System.out.println(h2.copyright);
    }
}


加上 final 就不会变化了！

8 类方法

类方法 = 静态方法
对象方法 = 实例方法 = 非静态方法

方法里访问了对象属性，这个方法，就必须是对象方法
否则可以是类方法

package 第1个程序.类方法;

public class Hero {

    public void AAA(){
        System.out.println("AAA");
    }

    public static void BBB(){
        System.out.println("BBB");
    }

    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.AAA();
        hero.BBB();
//        Hero.AAA();//错误
        Hero.BBB();
    }
}

9 属性初始化

9.1 对象属性初始化

1 声明该属性时，初始化
2 构造方法中，初始化
3 初始化块

package 第1个程序.a8_属性初始化;

public class Hero {
    public String name  = "some hero"; //声明时初始化
    protected float hp;
    float maxHP;
    {
        maxHP = 10000;
    }

    public Hero(){
        hp = 70;
    }
}

9.2 类属性初始化

1 声明该属性时，初始化
2 静态初始化块

package 第1个程序.a8_属性初始化;

// 类属性初始化
public class Hero2 {
    public String name  = "some hero"; //声明时初始化
    protected float hp;
    float maxHP;

    public static int Capacity = 8;

    public Hero2(){}

    static {
        Capacity = 10;
    }

    public static void main(String[] args) {
        System.out.println(Hero2.Capacity);
    }
}

9.3 练习

package 第1个程序.a8_属性初始化;

// 练习
public class Hero3 {
    public String name  = "some hero"; //声明时初始化
    {
        System.out.println("声明");
    }

    public Hero3(){
        name = "1";
        System.out.println("构造方法");
    }

    {
        name = "2";
        System.out.println("块");
    }

    public static void main(String[] args) {
        Hero3 h1 = new Hero3();
        System.out.println(h1.name);
    }
}

输出：

属性赋值顺序（优先级）：
1 属性默认初始化
2 属性显式初始化、初始化块
3 构造器中，初始化
4 对象.属性、对象.方法

qq_1403034144
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
接口 嵌套类
LiAphrodite的博客
07-19 194
接口 合同（契约） 线性表： 增加 头插/尾插/根据index插入 删除 头删/尾删/根据index删除 给定index返回指定数据/修改index位置数据，返回整体长度 语法： 定义接口（相当于类） Interface接口名称{ 方法名（自带public和abstarct） 给出的属性肯定是常量（自带public static final 限定符） 可以给出默认方法 defa...
JavaOOP-04-static关键字笔记.pdf
07-27
正确理解和使用`static`关键字对于编写高效、清晰的Java代码至关重要，尤其是在设计类的结构和管理资源时。同时，需要注意过度使用`static`可能导致代码耦合度增加，不易维护，因此应谨慎使用。
Java进阶07 嵌套类
weixin_33809981的博客
04-16 255
作者：Vamei 出处：http://www.cnblogs.com/vamei 欢迎转载，也请保留这段声明。谢谢！   到现在为止，我们都是在Java文件中直接定义类。这样的类出现在包(package)的级别上。Java允许类的嵌套定义。 这里将讲解如何在一个类中嵌套定义另一个类。  嵌套 内部类 Java允许我们在类的内部定义一个类。如果这个类是没有static修饰符，那么这样...
5.4 jmu-Java-04面向对象进阶-04-嵌套类-静态嵌套类
最新发布
weixin_73533788的博客
11-05 316
定义类，在该类内部创建一个静态嵌套类，该嵌套类包含：与，用于存放最小值最大值toString方法，格式见下面的输出样例。为类创建一个静态方法，对传递进来的数组找到其中的最大值和最小值并返回对象。PairResultmain方法说明输入样例输出样例思路：类方法：首先定义一个静态嵌套类PairResult，它有两个属性min和max，用于存储最小值和最大值（赋值为数组的第一个数值以防数组只有一个时报错）。然后定义了一个toString方法，用于将对象转换为字符串。
3.16 jmu-Java-04面向对象进阶-04-嵌套类-静态嵌套类 (10分)
ihopeyousuccess的博客
12-17 4585
16 jmu-Java-04面向对象进阶-04-嵌套类-静态嵌套类 (10分) 定义类ArrayUtils，在该类内部创建一个静态嵌套类PairResult，该嵌套类包含： 属性: private double min与private double max，用于存放最小值最大值 方法：toString方法，格式见下面的输出样例。 为ArrayUtils类创建一个静态方法PairResult findMinMax(double[] values)，对传递进来的数组找到其中的最大值和最小值并返回PairResu
嵌套类：静态嵌套类和非静态嵌套类
chuntiandejiaobu10的专栏
09-07 764
转自http://www.importnew.com/1153.html 内部类在维基百科的定义为:  面向对象编程中，内部类（又叫做嵌套类）是在另一个类或者接口中进行声明的类。内部类不同于子类（subclass）。（译者注：wiki的注解有误，内部类和嵌套类并不完全等同，详见下文。） 在Java中，上面的定义可以如下示例： public final class Clazz {
Java编程实训 Java开发基础入门教程1-04 面象对象编程初步-类和对象（共54页）.pptx
12-25
总的来说，Java编程实训中的"面象对象编程初步-类和对象"部分，主要讲解了如何使用类来定义对象的结构，如何创建对象并使用其属性和方法，以及封装的概念。这些都是学习Java编程的基础，对于理解和编写复杂的Java...
Java2-homework04
03-26
首先，Java作为面向对象的编程语言，其核心概念包括类、对象、封装、继承和多态。在作业中，我们可能会遇到如何定义类，创建和操作对象，以及如何利用这些特性来构建复杂程序的问题。封装是Java中的重要原则，它通过...
Java程序设计：chapter04 类和对象.ppt
06-20
在Java程序设计中，类和对象是核心概念，它们构成了面向对象编程的基础。面向对象编程（OOP）是一种编程范式，它基于“类”和“对象”的概念，将数据和操作数据的方法封装在一起。Java语言完全支持面向对象编程，其...
04 Java基础-springboot1
08-03
`run()`方法有两种重载形式，一种接受类对象和字符串数组作为参数，另一种接受对象数组和字符串数组。这些参数用于指定主配置类和应用启动时的参数。 `SpringApplication`的构造函数接收`ResourceLoader`和`Class...
java静态类和非静态类,java中静态的内部类和非静态内部类详细区别
weixin_32503491的博客
03-16 967
java内部类分为： 成员内部类、静态嵌套类、方法内部类、匿名内部类 。内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。package static_neibulei_yu_fei_static;public class Static_neibulei_Test {private static int eye = 2;private ...
【Java 面向对象】基础、Java程序的内存划分、嵌套类（内部类、静态嵌套类）、局部类、接口的升级问题（默认方法、静态方法）、instanceof
萌宅鹿的技术小屋
04-25 2489
面向对象对象的内存复杂对象的内存对象数组的内存思考：方法存储在哪里？Java程序的内存划分this、super注解（Annotation）访问控制（Access Control）toString方法static静态导入成员变量的初始化初始化块、静态初始化块单例模式（Singleton Pattern） Java笔记目录可以点这里：Java 强化笔记 这一章的笔记内容不是很全（其他章都比较全），...
java面向对象-------静态内部类、非静态内部类、匿名内部类
weixin_30555753的博客
05-20 136
一、静态内部列和非静态内部类package cn.zxg.oop;/** * 测试非静态内部类和静态内部类 */public class TestInnerClass { public static void main(String[] args) { //创建非静态内部类对象 Outer.Inner inner=new Outer(). new Inner();...
2023面向对象程序设计《实验3》-面向对象
m0_73793012的博客
03-22 2271
2023面向对象程序设计《实验3》-面向对象
静态嵌套类和内部类
qq_43608817的博客
11-16 699
什么是嵌套类以及内部类 ？ 可以在一个类的内部类定义另一个类，这种类称为嵌套类，它有两种类型 ： 静态嵌套类和非静态嵌套类；非静态嵌套类使用比较多，也称作为内部类（inner），其中内部类（inner）类又分为三种 ： 1.）在一个类（外部类）中直接定义的内部类； 2.）在一个方法（外部类的方法）中定义的内部类； 3.）匿名内部类。 一 ： 静态嵌套类 ： public class StaticT...
作业06-接口、内部类
weixin_30765475的博客
10-28 267
1. 本周学习总结 1.1 面向对象学习暂告一段落，请使用思维导图，以封装、继承、多态为核心概念画一张思维导图或相关笔记，对面向对象思想进行一个总结。 2. 书面作业 1. clone方法 1.1 在test1包中编写Employee类，在test2包中新建一个Test类，并在其main中新建test1包中的Employee的对象，然后使用clone方法克隆一个新对象，能否成功?为什么...
C#类的嵌套
weixin_34112181的博客
11-25 192
嵌套类（Nested Class）是在类中定义的类。以下把拥有内嵌类的类称为外部类。嵌套类分为静态嵌套类和非静态嵌套类，其中非静态嵌套类也被称为内部类。嵌套类在UML中是composite的另外一种代码表示形式，表示耦合度更高，并且与外部类更加紧密。一般类的访问修饰符可以定义为默认的internal或者public，而内嵌类就有比较多的选择，可以是为protected、internal、p...
7-4 jmu-Java-04面向对象进阶-01-接口-Comparable (5 分)
fangjial的博客
07-31 4380
Arrays.sort不能对自定义对象进行排序。现希望对自定义的PersonSortable类的对象，使用Arrays.sort进行排序。 1.编写PersonSortable类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toString函数：返回格式为：name-age 实现Comparable接口：实现先对nam...
jmu-java-04面向对象进阶-04-嵌套类-静态嵌套类
06-28
静态嵌套类是指在一个类中定义的静态类，它可以直接通过外部类名访问，...静态嵌套类可以访问外部类的静态成员和方法，但不能访问外部类的非静态成员和方法。静态嵌套类通常用于封装一些与外部类相关的工具类或常量类。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

qq_1403034144

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值