零基础学Java（Day7）

#Java学习记录一周！

Object超类

Object是所有类的父类

练习

重写equals

    public boolean equals(Object o){
        if(o instanceof Item){
            Item it=(Item) o;
            return this.price==it.price;
        }
        return false;
    }

抽象类

定义

在类中声明一个方法，这个方法没有实现体，是一个“空”方法

这样的方法就叫抽象方法，使用修饰符“abstract"

当一个类有抽象方法的时候，该类必须被声明为抽象类

一个类一旦被声明为抽象类，就不能直接被实例化

练习

Item类

public abstract boolean disposable();
public static void main(String[] args)
    {
        Item Blood=new LifePotion();
        Blood.name="血瓶";
        Blood.price=50;

        Item Shoe=new Armor();
        Shoe.name="草鞋";
        Shoe.price=300;

        Item Long=new Weapon();
        Long.name="长剑";
        Long.price=350;

        System.out.println(Blood.disposable());
        System.out.println(Shoe.disposable());
        System.out.println(Long.disposable());
    }

Weapon类

package property;
public class Weapon extends Item{
    int damage;    //攻击力
    public boolean disposable(){
        return false;
    }
    public static void main(String[] args)
    {
        Weapon infinityEdge=new Weapon();
        infinityEdge.damage=130;
        infinityEdge.name="无尽之刃";
        infinityEdge.price=3600;
    }
}

以此类推

内部类

非静态内部类

 class BattleScore{
        int kill;
        int die;
        int assit;
        public void keng(){
            if(die>=8)
                System.out.println(name+"也太坑了！");
        }
        public void lengendary(){
            if(kill>=8)
                System.out.println(name+"超神！");
        }
    }
        public static void main(String[] args) {
        Hero garen=new Hero();
        garen.name="盖伦";
        BattleScore score=garen.new BattleScore();
        score.kill=9;
        score.lengendary();
        }

静态内部类

    static class EnemyCrystal{
        int Hp=5000;
        private String name;

        public void checkIfVictory(){
            if(Hp==0){
                Hero.battleWin();
                System.out.println(name+"win this game!");
            }
        }
    }
        public static void main(String[] args) {
        Hero garen=new Hero();
        garen.name="盖伦";
        Hero.EnemyCrystal crystal=new Hero.EnemyCrystal();
        crystal.checkIfVictory();
        }

匿名类

匿名类指的是在声明一个类的同时实例化它，使代码更加简洁精练
通常情况下，要使用一个接口或者抽象类，都必须创建一个子类

有的时候，为了快速使用，直接实例化一个抽象类，并“当场”实现其抽象方法。
既然实现了抽象方法，那么就是一个新的类，只是这个类，没有命名。
这样的类，叫做匿名类

    String name; //姓名
          
    float hp; //血量
          
    float armor; //护甲
          
    int moveSpeed; //移动速度
      
    public abstract void attack();
      
    public static void main(String[] args) {
          
        ADHero adh=new ADHero();
        //通过打印adh，可以看到adh这个对象属于ADHero类
        adh.attack();
        System.out.println(adh);
          
        Hero h = new Hero(){
            //当场实现attack方法
            public void attack() {
                System.out.println("新的进攻手段");
            }
        };
        h.attack();
        //通过打印h，可以看到h这个对象属于Hero$1这么一个系统自动分配的类名
          
        System.out.println(h);
    }

本地类

本地类可以理解为有名字的匿名类
内部类与匿名类不一样的是，内部类必须声明在成员的位置，即与属性和方法平等的位置。
本地类和匿名类一样，直接声明在代码块里面，可以是主方法，for循环里等等地方

    String name; //姓名
          
    float hp; //血量
          
    float armor; //护甲
          
    int moveSpeed; //移动速度
      
    public abstract void attack();
      
    public static void main(String[] args) {
          
        //与匿名类的区别在于，本地类有了自定义的类名
        class SomeHero extends Hero{
            public void attack() {
                System.out.println( name+ " 新的进攻手段");
            }
        }
         
        SomeHero h  =new SomeHero();
        h.name ="地卜师";
        h.attack();
    }

匿名类中使用外部变量

在匿名类中使用外部的局部变量，外部的局部变量必须修饰为final

**注：**在jdk8中，已经不需要强制修饰成final了，如果没有写final，不会报错，因为编译器偷偷的帮你加上了看不见的final

默认方法

默认方法是JDK8新特性，指的是接口也可以提供具体方法了，而不像以前，只能提供抽象方法

Mortal 这个接口，增加了一个默认方法 revive，这个方法有实现体，并且被声明为了default

package charactor;

public interface Mortal {
    public void die();
    default public void revive(){
        System.out.println("该英雄复活了");
    }
}

假设没有默认方法这种机制，那么如果要为Mortal增加一个新的方法revive,那么所有实现了Mortal接口的类，都需要做改动。

但是引入了默认方法后，原来的类，不需要做任何改动，并且还能得到这个默认方法

通过这种手段，就能够很好的扩展新的类，并且做到不影响原来的类

练习

Q：
为AD接口增加一个默认方法 attack()
为AP接口也增加一个默认方法 attack()
问： ADAPHero同时实现了AD,AP接口，那么 ADAPHero 对象调用attack()的时候，是调用哪个接口的attack()?
A：
当实现多接口的时候，默认方法重复的时候，类必须重写该方法，并且可以根据自己的需求调用具体的接口方法

UML综合训练

Animal

public abstract class Animal {
    protected int legs;
    protected Animal(int leg){legs=leg;}
    public abstract void eat();
    public void walk(){
        if(legs>0)System.out.println("它们用"+legs+"只腿行走");
        else System.out.println("鱼只会游泳");
    }
}

Spider

public class Spider extends Animal {
    protected Spider(int leg) {
        super(leg);
    }

    @Override
    public void eat() {
        System.out.println("它们啥都吃");
    }
    public static void main(String[] args){
        Spider s=new Spider(8);
        s.eat();
    }
}

Pet

public interface Pet {
    public String getName();

    public void setName(String name);

    public void play();
}

Cat

public class Cat extends Animal implements Pet {
    String name;

    protected Cat(String name) {
        super(4);
        this.name=name;
    }

    public Cat(){
        this(" ");
    }

    public void eat(){
        System.out.println(name+"主子啥都吃");
    }

    @Override
    public String getName() {
        return this.name;
    }

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

    @Override
    public void play() {
        System.out.println(name+"主子正在玩耍");
    }
    public static void main(String[] args){
        Cat cat1=new Cat();
        cat1.setName("Tom");
        cat1.eat();
        cat1.play();
    }
}

Fish

public class Fish extends Animal implements Pet {
    private String name;

    protected Fish(int leg) {
        super(0);
    }

    @Override
    public void eat() {
        System.out.println("大鱼吃小鱼，小鱼吃虾米");
    }
    @Override
    public String getName() {
        return this.name;
    }

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

    @Override
    public void play() {
        System.out.println("鱼儿在水里游");
    }
    public Fish(){
        super(0);
    }
    public static void main(String[] args){
        Fish fish=new Fish();
        fish.play();
        fish.eat();
        fish.walk();
    }
}

字符串综合练习

输入一个整数n，生成长度为n的随机字符串作为密码（字符串包括数字、大小写字母）
穷举法递归破解密码（明天写个多层for循环破解的）

import java.io.OutputStream;
import java.util.Scanner;


public class Main {
    public static String  randomString(int n){
        short start='0';
        short end='z'+1;
        char[] cs=new char[n];
        for(int i=0;i<n;i++){
            while(true){
                char c=(char)((Math.random()*(end-start))+start);
                if(Character.isDigit(c)||Character.isLetter(c)){
                    cs[i]=c;
                    break;
                }
            }
            }
        String str=new String(cs);
        return str;
        }
    public static void guessNum(char[] c, int index, String password){
        boolean flag = false;
        if (flag) {
            return;
        }
        for (int i = '0'; i <= 'z'; i++) {
            if (!Character.isLetterOrDigit(i)) {
                continue;
            }
            c[index] = (char) i;
            if (index == c.length - 1) {
                String guess = new String(c);
                if (guess.equals(password)) {
                    System.out.println("已破解密码" + guess);
                    flag = true;
                    return;
                }
            }
            else {
                guessNum(c, index + 1, password);
            }

        }
    }
    public static void main(String[] args){
        System.out.println("请输入密码的长度");
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        char[] c=new char[n];
        String password=randomString(n);
        System.out.println(password);
        guessNum(c,0,password);
        }
}

不知道是否是算力的原因，n>5以后就无法破解了，如果有大神看到的话希望能指点一二Orz
欢迎在学习Java的朋友一起交流学习0.0

我的学习记录
Day4
Day5
Day6