oopDay4-继承，依赖，聚合(即extends与implements的使用)

Day4

1.继承，依赖，聚合

1.is a (继承的关系)

​ Pet

​ ↗ ↖

​ Cat Dog

2.use a 使用（依赖的关系）

public classTest{
	public void ting(Pet p){
	p.jiao();
	}
}

3.has a 拥有（聚合的关系）—>涉及到一对一，多对一，一对多

​ 学生 有 宠物

public class Student{
    String name;
    int age;
    Pet p;		//学生拥有宠物
}

​ 班级的多个学生

public class BanJi{
    String banhao;
    Student[] stus;
}

2.登录功能

普通

用户名 [ ]

密码 [ ]

oop

MyUser 类

String login;用户名

String pwd;密码

double money;金额

MyUser zsf = new MyUser();

​ zsf.login=“张三丰”;

​ zsf.pwd=“123”;

​ zsf.money=100;

MyUser zsf = new MyUser();

​ zsf.login=“张三丰”;

​ zsf.pwd=“123”;

​ zsf.money=100;

MyUser zwj= new MyUser();

​ zwj.login=“张无忌”;

​ zwj.pwd=“456”;

​ zwj.money=10000;

MyUser[ ] users = new MyUser[3];

​ user[0]=zsf;

​ user[1]=zwj;

3.（考试机）练习

需求

题[] 总题库 里面放的所有的题

题[] 临时题库 里面放的是随机抽出的3道题

学生[] 学生登录后可以答题 答题时循环展示 临时题库的题干和选项内容 学生作答后可以给出正确答案并且计算分值。

分析 oop

学生类

​ 姓名 学号 登录名 密码

题类

​ 题干 以下选项中谁最帅

​ 选项 A.张三 B.张昊宇 C.李四 D.王五

​ 答案 B

​ 分 5

程序结构

考试机类

​ 题[] 总题库

​ 题[] 临时题库

​ 学生[] 学生们

//构造方法中初始化上面的总题库和学生

//出题的方法

（随机三次从总题库中取出题放入到临时题库中）

//登陆的方法

//考试的方法

（调用 登录—>出题—>循环临时题库给出题目并且作答计算分值）

代码

1.题类

public class Ti {
    public String tigan;//题干
    public String xuanxiang;//选项
    public String daan;//答案
    public int score;//得分

    public Ti(String tigan, String xuanxiang, String daan, int score) {
        this.tigan = tigan;
        this.xuanxiang = xuanxiang;
        this.daan = daan;
        this.score = score;
    }
}

2.学生类

public class Student {
    public String name;
    public String id;
    public String username;
    public String password;

    public Student(String name, String id, String username, String password) {
        this.name = name;
        this.id = id;
        this.username = username;
        this.password = password;
    }
}

3.方法

import java.util.Scanner;

public class test {
    public Ti[] tiku;                       //总题库
    public Ti[] linshitiku=new Ti[3];       //临时题库
    public Student[] stu;                   //学生

    /**
     * 初始化学生和总题库
     */
    public test() {
        Ti t1=new Ti(" 1+1=","A 1 B 2 C 3 D 4","B",10);
        Ti t2=new Ti(" 1+3=?","A 1 B 2 C 3 D 4","D",10);
        Ti t3=new Ti(" 2*2=?","A 1 B 2 C 3 D 4","D",10);
        Ti t4=new Ti(" 2-3=?","A -1 B 2 C 3 D 4","A",10);
        Ti t5=new Ti(" 2/2=?","A 1 B 2 C 3 D 4","A",10);
        this.tiku= new Ti[]{t1, t2, t3, t4, t5};        //学生题库数组赋值部分
        Student stu=new Student("张","201801","张昊宇","123456");
        Student stu1=new Student("李","201802","李四","654321");
        this.stu= new Student[]{stu, stu1};
    }
    /**
     * 出题 随机三次从总题库中取出题放入到临时题库中。
     */
    public void chuti() {
        linshitiku = new Ti[3];
        int index = 0;
        for (int i = 0; i < 3; i++) {
            //random会给出随机小数，这里需要去选择数组的位置，所以需要强转
            //ztk.length这个给的是一个区间
            int xx = (int) (Math.random() * tiku.length);
            //测试在数组中选取哪个位置
//            System.out.println((int) (Math.random() * ztk.length));
            //如果重复怎么办
            Ti t = tiku[xx];
            boolean b = true;
            for (int j = 0; j < linshitiku.length; j++) {
                if (linshitiku[j] == t) {
                    i--;       //外面在此循环
                    b = false;
                    break;
                }
            }
            if (b == true) {
                linshitiku[index++] = tiku[xx];
            }
        }
    }

    /**
     * 登录
     * @return 登录对象
     */
    public Student login(){
        Student s=null;
        Scanner sc=new Scanner(System.in);
        System.out.print("用户名：");
        String username=sc.next();
        System.out.print("密  码：");
        String password=sc.next();
        for (int i = 0; i <stu.length ; i++) {
            if (stu[i].username.equals(username)&&stu[i].password.equals(password)){
                s=stu[i];
                System.out.println("登录成功");
                break;
            }
        }
        return s;
    }
    /**
     * 考试方法调用  登录--> 出题  --> 循环临时题库 给出题目 并且作答 计算分值
     */
    public void kaoshi(){
        Student s=login();
        if (s!=null) {
            chuti();            //调完出题方法之后 lstk 中才会有内容
            int dui=0;
            int cuo=0;
            int zong=30;
            int score=0;
            Scanner sc=new Scanner(System.in);
            System.out.println("----------------考试开始------------------");
            for (int i = 0; i <linshitiku.length ; i++) {
                System.out.println(linshitiku[i].tigan);
                System.out.println(linshitiku[i].xuanxiang);
                //输入答案并判断正确与否
                System.out.print("请输入的答案");
                String da=sc.next();
                //equalsIgnoreCase判断输入的是否在给定的组合中，并且不受大小写影响
                if (linshitiku[i].daan.equalsIgnoreCase(da)){
                    System.out.println("回答正确");
                    score+=linshitiku[i].score;
                    dui++;
                }else{
                    cuo++;
                    System.out.println("回答错误");
                }
                System.out.println("------------------------------------");
            }
            System.out.println("----------------考试结束------------------");
            System.out.println("本次测试共三题（共30分），答对"+dui+"题，打错"+cuo+"，"+s.name+"总成绩"+score);
            System.out.println("----------------考试结果------------------");
        }else {
            System.out.println("登录失败！");
        }
    }

    public static void main(String[] args) {
        test t=new test();
        t.kaoshi();
    }
}

运行结果

4.修饰符

​ 属性 方法 类

静态 static √ √ ×

最终 final √ √ √

抽象 abstract × √ √

4.1static

4.1.1全局唯一

static静态的跟类走，（全局唯一）

非静态的跟对象走

4.1.2方法调用

静态属性和静态方法

​ 通过类名.静态的属性方法的方式进行调用

4.1.3优先加载

静态先于非静态（称之为优先加载）

先有类再有对象，而静态方法是跟类走的，非静态方法是跟对象走的。

普通方法 可以直接 调用 普通方法 和 普通属性

普通方法 可以直接 调用 静态方法 和 静态属性

静态方法（不能直接）调用 普通方法 和 普通属性

静态方法 可以直接 调用 静态方法 和 静态属性

（静态不能直接调用非静态，而普通的都可以调用）

4.1.4块{ }

块{ } :其实就是一段代码

静态块 static{代码} 全局唯一，只加载一次

非静态块 {代码} 跟对象走

同等级别的块和属性 谁在上面先加载谁

4.1.5加载顺序

类的加载顺序

new 类()

静态属性和块 非静态属性和块—>构造方法—>普通方法

4.2final

final 最终的

可以修饰 类 属性 方法

修饰类 不能被继承

修饰属性 不能被改写 是常量

修饰方法 不能被重写

4.3abstract

抽象 abstract

可以修饰 类 方法

修饰类叫抽象类

​ 1.不能自己new自己

​ 2.抽象类中可以有抽象方法

修饰方法叫抽象方法 （限定了子类中一定会重写该方法）

​ 抽象的方法 没有方法体 只能定义在抽象类中

public abstract class 类名{
    public abstract void c()''
}
//错误演示
main(){
    类名 test = new 类名();	×不可以自己new自己
}

意义：

抽象类中的抽象方法是一种协议，用来限定其子类中一定会实现该方法

倾向于是一种协议规范

4.3.1匿名内部类

不能自己new自己

但可以new出来重写一个匿名内部类

new	抽象类或接口(){重写对应方法};

4.3.2内部类和静态内部类

内部类

1.亲戚生成两个类文件,借居不能用public

2.定义在内的内部 是属性

静态内部类

用static修饰 定义在类的内部的内部类

4.4interface

接口 定义的关键字 interface (接口时特殊的抽象类)

接口是纯粹的一种协议 一种规范 用来限定子类的行为模式，特点是：

1.接口中的方法都是抽象的共有方法

2.接口中的属性都是共有的静态常量

interface 接口 ； implements 实现

子类 实现 父接口

public interface Ipad{
   static final int RONGLIANG=4000;	//常量定义需要大写(接口中static final是默认的)
    void play();
}
public class HuaWeiPad implements Ipad,其他接口{
    public void play(){
        System.out.println("播放视频")
    }
} 

接口是干爹,告诉你有什么方法,但需要你重写,自己来实现

5.总结

类 和 类 用 继承 extends

类 和 接口 用 实现 implements

接口 和 接口 用 继承 extends