作业：
给定一个大小为 n 的数组 nums ，返回其中的多数元素。
多数元素是指在数组中出现次数大于 n/2 的元素。

[1,1,1,1,2,3,3]

public class Import {
    public static void main(String[] args) {
        int[] arr = {1, 1, 1, 1, 2, 3, 3};
        System.out.println(howe(arr));
    }

    public static int howe(int[] nums) {
        int left=0;
        int right=1;
        int count=1;
        while (left<right&&right<nums.length){
            if (nums[left]==nums[right]){
                count++;
                if (count> nums.length/2){
                    return nums[right];
                }
            }
           left++;right++;
        }
        return 0;
    }
}

作业：综合案例（用户博客管理系统）：

public class user {                        
    private String name;                   
    private int age;                       
    private String text;                   
                                           
    public user(String name, int age, Strin
        this.name = name;                  
        this.age = age;                    
        this.text = text;                  
    }                                      
                                           
    public String getName() {              
        return name;                       
    }                                      
                                           
    public void setName(String name) {     
        this.name = name;                  
    }                                      
                                           
    public int getAge() {                  
        return age;                        
    }                                      
                                           
    public void setAge(int age) {          
        this.age = age;                    
    }                                      
                                           
    public String getText() {              
        return text;                       
    }                                      
                                           
    public void setText(String text) {     
        this.text = text;                  
    }                                      
}              


import java.util.*;
public class Test<use, pwd> {
    static List list=new ArrayList();
    static String[] use={"123","456","","",""};
    static String[] pwd={"admin","user","","",""};
    static boolean flag=false;
    public static void main(String[] args) {
        begin();
    }
    public static void begin() {
        System.out.println("========欢迎进入用户管理系统=======");
        System.out.println("请输入：1.登录 2.注册 3.发布博客 4.删除博客 5.修改博客 6.查看博客");
        Scanner iu = new Scanner(System.in);
        int n = iu.nextInt();
        if (n == 1) {
            Login();
            begin();
        } else if (n == 2) {
            Registration();
            begin();
        } else if (n == 3) {
            Add();
            begin();
        } else if (n == 4) {
            Delete();
            begin();
        } else if (n == 5) {
            Alter();
            begin();
        }else if (n==6){
            Look();
            begin();
        }
        else {
            System.out.println("退出成功");
            System.exit(0);
        }
    }

    public static void Login() {     //登录
        Scanner iu = new Scanner(System.in);
        System.out.print("请输入用户名：");
        String a = iu.next();
        System.out.print("请输入密码：");
        String b = iu.next();
        for (int i = 0; i < use.length; i++) {
            if (a.equals(use[i]) && b.equals(pwd[i])) {
                flag = true;
                break;
            }
        }
        if (flag){
            System.out.println("登录成功");
        }else {
            System.out.println("登陆失败");
        }
    }
    public static void Registration(){      //注册
        int left=0;
        int right=0;
        Scanner iu=new Scanner(System.in);
        System.out.print("请输入用户名：");
        String a=iu.next();
        System.out.print("请输入密码：");
        String b=iu.next();
        use[left+2]=a;
        pwd[right+2]=b;
        System.out.println("密码注册成功!!");
        left++;right++;
        System.out.println(Arrays.toString(use));
        System.out.println(Arrays.toString(pwd));
    }
    public static void Add(){       //发布博客
        Scanner iu=new Scanner(System.in);
        System.out.println("请输入博客名字：");
        String a=iu.next();
        System.out.println("请输入博客类型：");
        String b=iu.next();
        System.out.println("请输入博客内容：");
        String c=iu.next();
        list.add(new user(a,b,c));
        System.out.println("添加成功！！");
    }
    public static void Delete(){    //删除博客
        boolean flag=false;
        Scanner iu=new Scanner(System.in);
        System.out.println("请输入博客的名字：");
        String a=iu.next();
        for (int i=0;i< list.size();i++){
            if (a.equals(list.get(i))){
                Iterator it= list.iterator();
                while (it.hasNext()){
                    list.remove(it.next());
                }
                flag=true;
                break;
            }
        }
        if (flag){
            System.out.println("删除成功");
        }else {
            System.out.println("集合中没有该元素，未删除成功");
        }
    }
    public static void Alter(){     //修改博客

    }
    public static void Look(){
        System.out.println("名字  类型  内容");
        for (int i=0;i< list.size();i++){
            System.out.println(list.get(i));
        }
    }
}

Team8（抽象类）
定义一个抽象的"Role"类有姓名年龄性别等成员变量
   1. 要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)
   再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法
   该方法不返回任何值同时至少定义两个构造方法。Role类中要体现出this的几种用法。
   2. 从Role类派生出一个"Employee"类该类具有Role类的所有成员
   构造方法除外并扩展 salary成员变量同时增加一个静态成员变量“职工编号 ID ”。
   同样要有至少两个构造方法要体现出this和super的几种用法
   还要求覆盖play()方法并提供一个final sing()方法。
   3. "Manager"类继承"Employee"类有一个final成员变量"vehicle"
   4. 在main()方法中制造Manager和Employee对象,并测试这些对象的方法

abstract class Role {
    private String name;
    private int age;
    private char sex;

    public Role(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public Role(){}

    public abstract void play();

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

public class Employee extends Role{    //派生类Employee
    private double salary;
    private int ID;
    public Employee(String name,int age,char sex,double salary){
        super(name,age,sex);
        this.salary=salary;
    }

    @Override
    public void play() {
        System.out.println("真的很厉害啊");
    }
    public final void sing(){
        System.out.println("这个方法已经被锁定，无法改变");
    }
}

public class Manager extends Employee{
    private final String vehicle;
    public Manager(String name, int age, char sex, double salary, String vehicle) {
        super(name, age, sex, salary);
        this.vehicle = vehicle;
    }

    public static void main(String[] args) {
        Manager m=new Manager("1",12,'女',100,"牛");
        Employee e=new Employee("2",13,'男',100);
        e.play();
        e.sing();
        m.play();
        m.sing();
    }
}

Team9（抽象类）
品尝饮料
1、建立一个Java抽象类Drink 应当 a、声明一个抽象方法taste() 该方法负责输出饮料的味道 b、声明int型常量来代表不同的饮料类型咖啡、啤酒、牛奶如 c、声明静态工厂方法getDrink(int drinkType) 根据传入的参数创建不同的饮料对象并返回该对象建议使用switch语句。该方法要求声明DrinkNotFoundException 当没有相对应的饮料类型时抛出该异常。

public abstract class Drink {
    public abstract void taste();

    static int a = 1;//咖啡
    static int b = 2;//啤酒
    static int c = 3;//牛奶

    public static String getDrink(int drinkType) throws DrinkNotFoundException {
        try {
            switch (drinkType) {
                case 1:
                    return "a";
                case 2:
                    return "b";
                case 3:
                    return "c";
                default:
                    throw new DrinkNotFoundException();
            }
        } catch (Exception e) {
            return "没有该饮料";
        }
    }

    private static class DrinkNotFoundException extends Exception {
    }

    public static void main(String[] args) throws DrinkNotFoundException {
        System.out.println(getDrink(5));
    }
}

2、建立Drink的具体子类 a、分别建立Drink的子类 Coffee 代表咖啡 Beer 代表啤酒 Milk 代表牛奶 ; b、实现taste()方法要求在控制台打印各自的味道特征。

public class Coffee extends Drink{
    public  void taste(){
        System.out.println("咖啡的味道很苦");
    }
}
public class Beer extends Drink{
    public void taste(){
        System.out.println("啤酒的味道有点苦");
    }
}
public class Milk extends Drink{
    public void taste(){
        System.out.println("牛奶的味道很纯");
    }
}

3、建立异常类DrinkNotFoundException a、继承Exception b、在Drink的方法getDrink(int drinkType)中声明引发DrinkNotFoundException异常当传入的参数没有相对应的饮料类型时抛出异常。 c、在使用getDrink方法的类中捕捉该异常。

public static String getDrink(int drinkType) throws DrinkNotFoundException {
        try {
            switch (drinkType) {
                case 1:
                    return "a";
                case 2:
                    return "b";
                case 3:
                    return "c";
                default:
                    throw new DrinkNotFoundException();
            }
        } catch (Exception e) {
            return "没有该饮料";
        }
    }
    public static void main(String[] args) throws DrinkNotFoundException {
        System.out.println(getDrink(5));
    }

4、建立Test测试类测试以上内容的正确性 a、编写main方法通过命令行传参的方式传入某种饮料的类型。 b、在main方法中调用Drink类的getDrink方法获得相应的饮料对象。注意捕获DrinkNotFoundException。 c、然后调用该饮料对象的taste()方法输出该饮料的味道。

import java.util.Scanner;
public class Test {
    public static void main(String[] args) throws DrinkNotFoundException {
        Coffee coffee=new Coffee();
        Beer beer=new Beer();
        Milk milk=new Milk();
        Scanner iu=new Scanner(System.in);
        int d=iu.nextInt();
        System.out.println(Drink.getDrink(d));
        if (d==1){
            coffee.taste();
        }
        if (d==2){
            beer.taste();
        }
        if (d==3){
            milk.taste();
        }
    }
}

5、编译程序并运行。
注意事项 1、仔细审题把题目要求理解准确 2、请注意多态性的运用 3、请注意代码的书写、命名符合规范应有适当的注释
输出结果：

3
c是牛奶
牛奶的味道很纯

内部类、static关键字、final

1.什么是内部类：内部类，指的就是定义在某个类内部的类。
如何定义内部类：

class outer{
    class inter{    //定义一个内部类
    private String name=" ";    //定义一个内部变量
    }
}

有哪些访问修饰符可以使用在内部类

public、default(包访问权限)、private、protected、static、final可以用在内部类上，局部内部类上不能有修饰符，或者只能有个final修饰符

如何在外界访问对象

public class Ce {
    static class In{        //内部类
        public String name="howe";
        public static void wu(){
            System.out.println("你好牛啊！！！");
        }
    }
    public static void main(String[] args) {    //在外界访问内部对象
     In a=new In();                         //创建一个内部对象，调用内部方法
     System.out.println(a.name);
     a.wu();
    }
}

2.static关键字

在类中，用static声明的成员变量为静态成员变量，也成为类变量。类变量的生命周期和类相同，在整个应用程序执行期间都有效。

用途：方便在没有创建对象的情况下进行调用(方法/变量)，static可以用来修饰类的成员方法、类的成员变量

3.final关键字

final关键字代表最终，不可被改变的

1. 可以用来修饰一个类
2. 可以用来修饰一个方法
3. 还可以用来修饰一个局部变量
4. 还可以用来修饰一个成员变量

（1）、当final修饰类时，当前这个类不能有任何子类，无法进行重写和覆盖

（2）、当final修饰方法时，这个方法就是最终方法，也就是不能被覆盖重写

（3）、当final修饰变量时，那么这个变量就无法进行改变

接口和抽象

Java接口：在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

接口与类相似点：

一个接口可以有多个方法。
接口文件保存在 .java 结尾的文件中，文件名使用接口名。
接口的字节码文件保存在 .class 结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

public interface JieKou {        //接口的声明
}

接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

接口语法：....implements 接口名称[，其他接口名称，其他接口名称...]

public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("吃东西");
   }
}

接口的多继承

在Java中，类的多继承是不合法，但接口允许多继承。

public interface Hockey extends Sports, Event        //接口多继承

Java抽象类

抽象类的概念：在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类的使用：

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

public abstract class Lei {        //定义抽象类
}

public abstract class Wang extend Lei{        //继承抽象类
}

抽象方法：Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   
}

声明抽象方法会造成以下两个结果：

如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

面向对象的三大特征

Java的继承、封装、多态

类的继承

class 父类 {
}
 
class 子类 extends 父类 {
}

public class Mouse extends Animal{
}

继承的特性

子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

注意：Java不支持多继承，但支持多重继承

单继承：Class A--->Class B

多重继承：Class A--->Classs B--->Class C

不同类继承同一个类：Class A--->Class C Class B--->Class C

一个类不能同时继承多个类

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

输出结果为：

animal : eat
dog : eat
animal : eat

final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

final 含义为 "最终的"。

使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：

声明类：
```
final class 类名 {//类体}
```
声明方法：
```
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
```
构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

Java 封装

封装的优点

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。

public class Person{
    private String name;
    private int age;

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

    public void setAge(int age){
      this.age = age;
    }

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

name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问。

Java 多态

多态是同一个行为具有多个不同表现形式或形态的能力，多态就是同一个接口，使用不同的实例而执行不同操作。

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

class Shape {
    void draw() {}
}
 
class Circle extends Shape {
    void draw() {
        System.out.println("Circle.draw()");
    }
}
 
class Square extends Shape {
    void draw() {
        System.out.println("Square.draw()");
    }
}
 
}

Java作业之面向对象篇