作业：
给定一个大小为 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 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 {
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 : eatfinal 关键字
final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。
final 含义为 "最终的"。
使用 final 关键字声明类，就是把类定义定义为最终类，不能被继承，或者用于修饰方法，该方法不能被子类重写：
-
声明类：
final class 类名 {//类体} -
声明方法：
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}构造器
子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
-
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()");
}
}
}
