对象和类:
对象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);
}
}