华清远见-重庆中心-JAVA面向对象阶段技术总结:

Lucky--w_w--99

已于 2022-11-22 20:56:41 修改

阅读量246

点赞数 1

文章标签： java 开发语言

于 2022-11-22 20:51:51 首次发布

本文链接：https://blog.csdn.net/weixin_45866771/article/details/127987595

版权

对象和类:

对象object:

某个类的具体实例.

类class:

是拥有相同属性和行为的对象的集合,设类的模板.

定义类:

修饰符 class 类名{
    //属性:定义变量
    //行为:定义方法
}

创建对象:

类名 变量名 = new 构造方法([参数]);

成员变量局部变量静态变量:

1.成员变量:定义在类中的变量,即类的属性.它有默认值,通过对象访问.

2.局部变量:定义在方法中的变量.它没有默认值,只能在方法中赋值后才能使用.

3.静态变量:特殊的成员变量,用final static 修饰,它有默认值,通过类名访问.

class Person{
    //成员变量
    String name;
    //静态常量
    final static String COUNTRY="中国"
    void info(){
        //局部变量
        int age = 20;
        System.out.println("我叫"+name+",今年"+age+"岁,是一个"+COUNTRY+"人");
    }
}

构造方法:

是一种特殊方法.方法名和类名一致,没有返回值.

访问修饰符 类名(){
    
}

1.没有返回值部分,方法名必须和类名一致.

2.在使用new关键字创建对象时,调用对应的构造方法.

3.每个类在定义后,都应藏着有一个无参的构造方法.

4.如果定义了有参数的构造方法,无参构造方法就会失效,如果想要用无参构造方法,就要再写出来.

5.构造方法通常用于限制创建对象时携带的参数,初始化成员变量.

6.构造方法之间都是重载关系,构造方法不能重写.

7.构造方法执行时,不一定会创建对象,如抽象类中有构造方法,但无法创建抽象类对象,只能在创建抽象类的子类时,自动调用抽象类的构造方法.

面向对象三大特性:

封装

将类中的属性使用private修饰,这样就能防止非当前类对其访问.

封装步骤:

1.给类中的所有属性添加private访问修饰符

2.给每个属性添加getxxx()的方法用于读取属性值

3.给每个属性添加setxxx()的方法用于给属性赋值

private String name;

public String getName() {
        return name;
    }

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

继承:

类A extend 类B,类A就是类B的子类,类A的对象就能直接访问类B中非私有成员.或接口A extent 接口B.

重写Override:

子类继承父类后,对父类中的非私有方法进行重写,达到拓展或重做的目的.

1.必须满足方法名返回值参数列表都相同.

2.访问权限不能比父类中的方法更严格.

3.不能抛出比父类中的方法更大的一场.

重载Overload:

在一个类中,某个方法在不同的参数下,表现不同的行为,同名不同参.

1.方法名必须相同.

2.参数列表必须相同.

3.与返回值无关.

this和super:

1.都可以当作对象或构造方法使用.

2.当作对象:this表示当前类的对象,super表示当前类的父类对象.

3.this或super当作对象使用时,只能用在非静态方法中.

4.当作构造方法:this()表示当前类的无参数构造方法,如果带参数就表示对应的参数的构造方法.

5.super()表示当前类的父类的无参构造方法,如果带参数就表示对应的参数的构造方法.

6.this()或super()只能用在另一个构造方法的首行.

在继承关系中,如果父类和子类都没有写出任何构造方法时,子类有一个隐藏的无参数构造方法,回自动调用父类中无参数的构造方法.

class Father{
}
class Son extends Father{
    /*
    这个构造方法是隐藏的
    */
    public Son(){
    super();
    }
}

如果父类中有参数的构造方法,没有参数的构造方法时,子类必须调用父类中的构造方法.

class Father{
    String name;
    public Father(String name){
    this.name=name;
    }
}
    class Son extends Father{
    public Son(){
        super("xxx");
    }
}

Object类:

1.是所有类的父类,任何类都间接地继承了该类,但没有明确地使用extends体现出来,所有类都可以访问Object类中的方法,或对其进行重写.

2.toString()就是Object类中的一个方法,在输出对象时自动调用,默认输出的是"类名@十六进制哈希码",通常在自定义类中,重写toString(),从而输出该类中的属性.

3.equals()也是Object类中的一个方法,用于比较两个对象是否相同,默认使用==比较,即比较内存地址,通常需要重写该方法,自定义判断两个对象是否相同时所需的参数.

向上转型:

子类对象可以直接使用父类变量保存,即多态.

Person p = new Person();
Object obj = p;

向下转型:

Animal an = new Animal;
//Animal必须是cat的父类
Cat c = (Cat) an;

多态:

1.在继承关系中,子类的对象可以保存到父类的变量中.

2.多态通常应用于定义方法时,形参为一个父类或接口类型变量,实参可以是子类对象.

无法通过父类变量调用子类独有的方法,如果调用了父类的方法时,执行重写后的内容.

父类/接口 对象 = new 子类();
public class Father{
    public void smoke(){
        System.out.println("father smoking");
    }
}
    public class Son extends Father{
    public void play(){
        System.out.println("son playing");
    }
    @Override
    public void smoke(){
        System.out.println("son smoking");
    }
}
public class Main(){
    public static void main(String[] args){
    Father f = new Father();
    f.smoke();//父类中的方法
    Son son = new Son();
    son.play();
    son.smoke();//调用的是重写后的方法
    //多态
    Father father = new Son();
    //father.play();无法调用
    father.smoke();//调用的是重写后的方法
    }
}

访问修饰符:

	当前类	当前包	不同包中的子类	不同包中的非子类(同一个项目中的不同类)
public	√	√	√	√
protected	√	√	√	×
不写	√	√	×	×
private	√	×	×	×

final:

1.用于修饰属性方法和类.

(1)修饰属性:变量变为常量,不能改变其中的值.

(2)修饰方法:方法为最终方法,不能重写.

(3)修饰类:类为最终类,不能被继承.

abstract:

1.用于修饰类和方法,表示抽象的.

(1)修饰方法,方法成为抽象方法,没有方法体.同时该方法的所在类也一定要用abstract修饰,让其成为抽象类,

(2)抽象方法只能出现在抽象类中,不能出现在普通类中.

(3)抽象类中可以没有抽象方法.

(3)抽象类中有构造方法,但该构造方法只会在new抽象类的子类对象时会自动调用,抽象类不能创建自身对象.

(4)抽象类通常需要被继承,一旦有子类继承了抽象类,就必须要重写抽象类中的所有抽象方法.

interface:

1.用于定义接口的关键字,代替class.

2.如果某个抽象类中全部都是抽象方法时,可以将这个类改为接口.

(1)接口是一个完全抽象类,其中的方法都是public abstract修饰的抽象方法,没有方法体,其中的属性都是public final static修饰的静态常量.

(2)接口中没有构造方法,不能创建对象.

(3)接口通过impls实现,实现它的类称为该接口的实现类.

(4)一个类可以同时实现多个接口.

(5)一个类实现接口后,必须重写其中的抽象方法.

(6)JDK1.8后,可以在接口中定义defau方法和statiff,该方法不能重写.

static:

1.可以修饰方法属性或代码块.被修饰的内容称为静态成员.

2.静态成员在类加载时就会保存到内存中,所以访问静态成员时,无需对象,直接通过类名即可访问.

3.当某个属性或方法被高度重用时可以将其定义为静态的,之后通过类名调用.

4.还可以在类中定义静态代码块static{},在类加载时自动执行的代码块.

(1)静态方法中无法使用非静态成员.

(2)普通方法中可以使用静态成员.

个人总结:

在往你定义的数组内存数据时,去重复的方法:

 public void addHero(Hero hero){
        for (int k = 0; k < list.length; k++) {
            for (int i = 0; i < list.length; i++) {
                if (list[i]!=null&&list[i].equals(hero)){
                    System.out.println("添加不成功");
                    return;
                }
            }
            if (list[k]==null){
                list[k]=hero;
                System.out.println("添加成功");
                break;
            }
        }

    }

 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Hero hero = (Hero) o;
        return hp == hero.hp &&
                Objects.equals(name, hero.name) ||
                Objects.equals(country, hero.country) ||
                Objects.equals(weapon, hero.weapon) ||
                Objects.equals(skill, hero.skill);
    }

Hero

package User;

import java.util.Objects;

public class Hero {
    private String name;
    private String country;
    private String weapon;
    private String skill;
    private int hp = 1000;


    @Override
    public String toString() {
        return "Hero{" +
                "name='" + name + '\'' +
                ", country='" + country + '\'' +
                ", weapon='" + weapon + '\'' +
                ", skill='" + skill + '\'' +
                ", hp=" + hp +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Hero hero = (Hero) o;
        return hp == hero.hp &&
                Objects.equals(name, hero.name) ||
                Objects.equals(country, hero.country) ||
                Objects.equals(weapon, hero.weapon) ||
                Objects.equals(skill, hero.skill);
    }


    public Hero(String name, String country, String weapon, String skill) {
        this.name = name;
        this.country = country;
        this.weapon = weapon;
        this.skill = skill;
    }

    public Hero() {

    }

    public String getName() {
        return name;
    }

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

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getWeapon() {
        return weapon;
    }

    public void setWeapon(String weapon) {
        this.weapon = weapon;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp;
    }


}

GameRle

package User;

public class GameRole {
     Hero[] list = new Hero[10];

    public GameRole() {

    }

    public void addHero(Hero hero){
        for (int k = 0; k < list.length; k++) {
            for (int i = 0; i < list.length; i++) {
                if (list[i]!=null&&list[i].equals(hero)){
                    System.out.println("添加不成功");
                    return;
                }
            }
            if (list[k]==null){
                list[k]=hero;
                System.out.println("添加成功");
                break;
            }
        }

    }
    
    public void heroAll(){
        int i=1;
        System.out.println("查看英雄信息");
        System.out.println("编号\t名称\t阵营\t武器\t技能\t血量");
        for (Hero h:list){
            if (h!=null){
                System.out.println(i+"\t"+h.getName()+"\t"+h.getCountry()+"\t "+h.getWeapon()+"\t"+h.getSkill()+"\t"+h.getHp());
            }
            i++;
        }
    }
    public Hero findHero(int i){
        if(list[i]!=null) {
            return list[i];
        }

        return null;
    }

    public GameRole(Hero[] list) {
        this.list = list;
    }

    public Hero[] getList() {
        return list;
    }

    public void setList(Hero[] list) {
        this.list = list;
    }

    public void addHero() {
    }
}

Main

package User;

import java.awt.*;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) throws InterruptedException{
        Scanner sc = new Scanner(System.in);
       /* System.out.println("1.增加英雄");
        System.out.println("2.查看英雄");
        System.out.println("3.选择英雄");*/
        Main m = new Main();
        GameRole gr = new GameRole();

        while (true){
            System.out.println("1.增加英雄");
            System.out.println("2.查看英雄");
            System.out.println("3.选择英雄PK");
            switch (sc.nextInt()) {
                case 1:
                    System.out.println("增加英雄:");
                    System.out.println("英雄名称:");
                    String name = sc.next();
                    System.out.println("英雄阵营:");
                    String country = sc.next();
                    System.out.println("英雄武器:");
                    String weapon = sc.next();
                    System.out.println("英雄技能:");
                    String skill = sc.next();
                    Hero hero = new Hero(name, country, weapon, skill);
                    gr.addHero(hero);
                    break;
                case 2:
                    gr.heroAll();
                    break;
                case 3:
                    System.out.println("请输入英雄编号");
                    int b = sc.nextInt();
                    int b1 = sc.nextInt();
                    m.PK(gr.findHero(b-1),gr.findHero(b1-1));
                    break;
            }
        }
    }
    public void PK(Hero hero1,Hero hero2) throws InterruptedException {
        System.out.println(hero1.getName()+"登场");
        System.out.println(hero2.getName()+"登场");
        Random rd = new Random();
        while (true){
            Thread.sleep(500);
            if (hero1.getHp()<=0){
                System.out.println(hero1.getName()+"已阵亡");
                break;
            }
            if (hero2.getHp()<=0){
                System.out.println(hero2.getName()+"已阵亡");
                break;
            }
            int at = rd.nextInt(9)+4;
            if (at==12);{
                int hurt1=rd.nextInt(101)+100;
                int hurt2=rd.nextInt(101)+100;
                hero2.setHp(hero2.getHp()-hurt1);
                hero1.setHp(hero1.getHp()-hurt2);
                System.out.println(hero1.getName()+"使用"+hero1.getWeapon()+"对"+hero2.getName()+"发动了"+hero1.getSkill()+"造成了"+hurt1+"点伤害,"+"剩余血量"+hero2.getHp());
                System.out.println(hero2.getName()+"使用"+hero2.getWeapon()+"对"+hero1.getName()+"发动了"+hero2.getSkill()+"造成了"+hurt2+"点伤害,"+"剩余血量"+hero1.getHp());
            }
            if (at%3==0){
                int hurt1=rd.nextInt(101)+100;
                hero2.setHp(hero2.getHp()-hurt1);
                System.out.println(hero1.getName()+"使用"+hero1.getWeapon()+"对"+hero2.getName()+"发动了"+hero1.getSkill()+"造成了"+hurt1+"点伤害,"+"剩余血量"+hero2.getHp());
            }
            if (at%4==0){
                int hurt2=rd.nextInt(101)+100;
                hero1.setHp(hero1.getHp()-hurt2);
                System.out.println(hero2.getName()+"使用"+hero2.getWeapon()+"对"+hero1.getName()+"发动了"+hero2.getSkill()+"造成了"+hurt2+"点伤害,"+"剩余血量"+hero1.getHp());
            }
            else {
                hero2.setHp(hero2.getHp()-10);
                hero1.setHp(hero1.getHp()-10);
                System.out.println(hero1.getName()+"对"+hero2.getName()+"使用了普通攻击造成了10点伤害,"+"剩余血量"+hero2.getHp());
                System.out.println(hero2.getName()+"对"+hero1.getName()+"使用了普通攻击造成了10点伤害,"+"剩余血量"+hero1.getHp());

            }
        }
        hero1.setHp(1000);
        hero2.setHp(1000);
    }
}

Lucky--w_w--99

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
华清远见-重庆中心-JAVA面向对象阶段技术总结:

修饰符 class 类名{//属性:定义变量//行为:定义方法}k++) {i++) {System.out.println("添加不成功");return;}}System.out.println("添加成功");break;
复制链接

扫一扫