Java学习第二周总结
内容概括：ArrayList集合、二维数组、面对对象（类、属性、方法）、面对对象的基础运用、面对对象的案例、类之间的关系、面对对象三大特征之一之继承、游离块、static、final关键字、可变长参数、递归、Java中的内存分配、静态、抽象类、接口的简单了解和基本运用
一、ArrayList集合、二维数组、面对对象（类、属性、方法）
ArrayList集合(底层使用数组进行处理的集合)
(1)特点：是一个底层使用数组进行实现的,可以自动进行扩容的有序集合。初始容量为10,如果元素已经存满了,java自动给集合进行元素扩容。
(2)常用方法
/**
add(E e):将指定的元素追加到此列表的末尾。
add(int index, E element):在此列表中的指定位置插入指定的元素。
int index:代表指定的下标 E element:代表元素
addAll(Collection<? extends E> c) 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
将一个集合中的所有的元素追加到另外一个集合末尾
addAll(int index, Collection<? extends E> c) 将指定集合中的所有元素插入到此列表中，从指定的位置开始。
clear() 从列表中删除所有元素。
get(int index) 返回此列表中指定位置的元素。
indexOf(Object o) 返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
判断列表中是否有此元素 isEmpty() 如果此列表不包含元素，则返回 true 。
remove(int index) 删除该列表中指定位置的元素。
remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。
set(int index, E element) 用指定的元素替换此列表中指定位置的元素。
size() 返回此列表中的元素数。
toArray() 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。 将集合转换为数组
*/2、二维数组
(1)定义:
1、数据类型[][] 数组名 = new 数据类型[m][n];
m:二维数组中一维数组的个数
n:一维数组中元素的个数
m必须有值,n可以没有
每个一维数组的元素下标也是从0开始的
二维数组中一维数组的定位也是从0开始的
2、数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...},{元素1,元素
2...}...};
数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2...},{元素1,元素2...}...};
在二维数组中一维数组的元素的个数是不一样的
3、面对对象（类、属性、方法）
类：类主要以属性和方法组成，是用class声明的一个事物抽象出来的事物的具象化，类的命名要做到见名知意
属性：类似于之前学过的全局变量，命名也要做到见名知意，是事物的本质描述，比如大小、重量、名称等
方法：方法是类中的功能的具体实现，具体到事物上是事物的行为，比如人会跑、会吃饭、会娱乐等，方法命名也要做到见名知意
面向对象的思想：不同于面向过程，面向对象不重视过程的具体实现，而是更加注重对象的属性和其行为，比如现在一个人要开门，面向过程强调怎么打开门，强调的是开门的流程，而面向对象则是把门看成一个对象可以抽象出一个关于门的类，门的特征如重量，高度，品牌，材质等特征作为类的属性定义在类中，人要打开门，此时门作为对象，开门和关门都成为了门的行为，在类中体现为具体方法，人作为行为主体但是开门关门却并不是人的行为了；
访问控制修饰符：作用范围从大到小进行排序：
public > protected > default > private,其中public和private最为常用
4、练习题中存在的问题和疑惑
初涉综合案例
public class Atm {
ArrayList<User> user = new ArrayList<User>();
Scanner sc = new Scanner(System.in);
//1、注册功能
public void login(){
System.out.println("请输入您的姓名");
String name = sc.next();
System.out.println("请输入您的账号");
double id = sc.nextDouble();
System.out.println("请输入您的性别");
String sex = sc.next();
System.out.println("请输入您的初始余额");
double money = sc.nextDouble();
System.out.println("请输入您的密码");
String password = sc.next();
User user01 = new User(name,id,sex,money,password);
user.add(user01);
}
//2、登录功能
public void enter(){
System.out.println("请输入您的账号");
double id = sc.nextDouble();
boolean flag = true;
int index = -1;
for (int i = 0; i < user.size(); i++) {
if (user.get(i).getId()==id){
for (int j = 0; j < 3; j++) {
System.out.println("请输入您的登录密码");
String passWord = sc.next();
if (user.get(i).getPassWord().equals(passWord)){
System.out.println("登录成功！！！");
flag = false;
index = i;
break;
}else{
System.out.println("密码输入错误，请重新输入（这是第"+(j+1)+"次登录");
}
}
}
}
if (flag){
System.out.println("很遗憾，三次登录都失败了");
}else {
while (true) {
System.out.println("*********************************************");
System.out.println("***************欢迎登录ATM系统*****************");
System.out.println("*********************************************");
System.out.println("尊敬的" + user.get(index).getName() + "先生/女士，欢迎您登录此系统");
System.out.println("请选择功能: 1.存钱 2.取钱 3.查询余额 4.修改密码 5.退出");
System.out.println("***********************************************");
int num = sc.nextInt();
switch (num) {
case 1:
savemoney(index);
break;
case 2:
catchmoney(index);
break;
case 3:
showmoney(index);
break;
case 4:
changepwd(index);
break;
default:
System.out.println("输入有误，重新输入");
break;
}
if (num == 5){
break;
}
}
}
}
//3、存钱:
public void savemoney(int index){
System.out.println("请您输入想要存入的金额");
double money = sc.nextDouble();
user.get(index).setMoney(user.get(index).getMoney()+money);
System.out.println("存入成功，您当前余额为"+user.get(index).getMoney());
}
//4、取钱:
public void catchmoney(int index){
System.out.println("请您输入想要取出的金额");
double money = sc.nextDouble();
if (user.get(index).getMoney()>=money) {
user.get(index).setMoney(user.get(index).getMoney() - money);
System.out.println("取出成功，您当前余额为" + user.get(index).getMoney());
}else{
System.out.println("您的余额不足，当前余额为"+user.get(index).getMoney());
}
}
//5、查询余额:
public void showmoney(int index){
System.out.println("您当前余额为："+user.get(index).getMoney());
}
//6、修改密码：
public void changepwd(int index){
System.out.println("请输入您的旧密码");
String psw = sc.next();
int number = 0;
if (user.get(index).getPassWord().equals(psw)) {
while (true) {
System.out.println("请输入您的新密码");
String psw01 = sc.next();
System.out.println("请再次输入您的新密码");
String psw02 = sc.next();
if (psw01.equals(psw02)) {
System.out.println("密码修改成功，请重新登录");
number++;
} else {
System.out.println("两次密码不一致，请重新输入");
}
if (number>0){
break;
}
}
}
}
}二、面对对象的基础运用、面对对象的案例
1、面向对象的基础运用
(1)构造方法：
构造方法是用来创建对象的,一共有两种,一种是有参数的,一种是没有参数
分为:有参构造函数和无参构造函数
构造函数在有类并且有属性的基础上进行处理,构造方法其实就是为了个属性赋值,
有了属性才能有具体的对象
构造函数是一种特殊的方法,没有返回值数据类型,也没有void的修饰,方法名称和类名
完全相同,如果不同就不能叫构造函数
注意: 1、在你没有创建构造函数的时候,计算机默认的给你一个无参的构造函数,这时类的跳转会指向 类名
2、如果你有一个有参的构造函数,又想调用无参的构造函数那么就必须自己手动创建无参的构造函数
3、有参构造函数的参数括号中表示的都是属性,我们要完成属性赋值的过程
4、我们创建类的时候可以根据自己的需求定义多个构造函数,只要参数的个数是不同的,参数的类别是不同的,参 数的顺序是不同的就可以了 这个过程叫方法的重载
5、如果你能够一次性对所有的属性进行赋值就使用有参构造函数,如果你只是对部分属性进行赋值就使用无参构造函数+set的方法 如果你想要获取所有的值,那么就使用一个叫toString
(2)实体类的属性和方法总结：
一般的创建一个实体类，无参构造方法用于创建对象，在类中没有有参构造方法时，系统会默认给类一个无参构造方法，但是如果有了有参构造方法还要创建类的无参的对象时就需要自己手动创建一个无参构造方法了，有参构造方法可以根据具体功能或者自己的需求创建参数不同的构造方法，这种创建不同有参构造方法的行为叫做方法的重载，（方法重载是指两个方法的修饰符相同，方法的数据类型相同或同为无返回值方法，形参列表的个数或者数据类型不同，有时顺序不同构造方法也不同，更形参的命名无关），如果是用private修饰的属性要给属性提供get set方法方便对象调用，有需要可以重写toString();方法和equals();方法
2、案例：
/**
* 员工类
*
*/
public class Emp {
//工号
private String eid;
//姓名
private String name;
//性别
private String sex;
//年龄
private int age;
//工龄
private int workYear;
//工资
private double salary;
//部门
private String dept;
//电话
private String phone;
//alt + insert//无参构造函数 constructor 构造函数
public Emp() {
}
//有参构造函数
public Emp(String eid, String name, String sex, int age, int workYear, double
salary, String dept, String phone) {
this.eid = eid;
this.name = name;
this.sex = sex;
this.age = age;
this.workYear = workYear;
this.salary = salary;
this.dept = dept;
this.phone = phone;
}
//get set方法
public String getEid() {
return eid;
}
public void setEid(String eid) {
this.eid = eid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getWorkYear() {
return workYear;
}public void setWorkYear(int workYear) {
this.workYear = workYear;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String getDept() {
return dept;
}
public void setDept(String dept) {
this.dept = dept;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
//toString方法
@Override
public String toString() {
return "Emp{" +
"eid='" + eid + '\'' +
", name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
", workYear=" + workYear +
", salary=" + salary +
", dept='" + dept + '\'' +
", phone='" + phone + '\'' +
'}';
}
}
/**
* 处理员工相关逻辑的类
*/
public class EmpDao {
//定义一个集合用来存储我们创建的对象
//角色相当于我们后面要使用的数据库,用来存储对象相关的数据
//这个容器什么时候加载?当我们创建这个类的对象的时候就会对这个类进行加载//这个容器是自动加载,其他的方法是手动调用之后执行的
ArrayList<Emp> emps = new ArrayList<Emp>();
Scanner scanner = new Scanner(System.in);
//1、输入添加员工信息
public void add(){
//当我们对数据进行输入的时候,就相当于给前面的变量进行赋值了
//赋值完成之后我们就将这个变量的信息放到对象的构造函数的参数
//位置去,当调用了构造函数之后,就可以对属性进行赋值,就完成了
//对象的创建
System.out.println("请输入员工id");
String eid = scanner.next();
System.out.println("请输入姓名");
String name = scanner.next();
System.out.println("请输入性别");
String sex = scanner.next();
System.out.println("请输入年龄");
int age = scanner.nextInt();
System.out.println("请输入工龄");
int workYear = scanner.nextInt();
System.out.println("请输入工资");
double salary = scanner.nextDouble();
System.out.println("请输入部门");
String dept = scanner.next();
System.out.println("请输入电话");
String phone = scanner.next();
//将输入的值放在构造函数参数的部分
Emp emp = new Emp(eid,name,sex,age,workYear,salary,dept,phone);
//将我们创建好的对象放入到集合中去
emps.add(emp);
}
//2、查询所有员工信息
public void findAll(){
for(int i = 0; i < emps.size(); i++){
System.out.println(emps.get(i));
}
System.out.println("--------------------------------------------");
}
//3、根据部门查询员工信息
public void findByDept(){
System.out.println("3");
}
//4、查询某一个工资区间内的员工信息 工资最低值和最高值手动输入
public void findSalary(){
System.out.println("请输入你要查询工资的最小值:");
double sMin = scanner.nextDouble();
System.out.println("请输入你要查询工资的最大值:");
double sMax = scanner.nextDouble();
//循环对所有的元素进行遍历
for(int i= 0; i < emps.size(); i++){
if(emps.get(i).getSalary() >= sMin && emps.get(i).getSalary() <= sMax){
System.out.println(emps.get(i));
}
}}
//5、根据工龄查询员工信息
public void findByWorkYear(){
System.out.println("请输入你要查询的员工的工龄:");
}
//6、根据id删除员工信息
public void deleteByEid(){
System.out.println("6");
}
//7、根据部门删除员工信息
public void deleteByDept(){
System.out.println("7");
}
//8、根据工号更改员工部门或者薪资信息
public void updateByEid(){
System.out.println("8");
}
//9、根据工号查询员工信息
public void findByEid(){
System.out.println("9");
}
//当你的方法都是普通的方法,没有使用static进行修饰的时候,我们可以直接对本类中的其他的方法进行调用
//方法和方法之间也可以相互调用,如果你需要将另外一个类中的方法进行执行和调用那么我们必须创建你要调
//用的方法的类对象。如果方法和方法和方法之间执行的时候需要有值的传输,那么只需要给方法添加一个返回
//值就可以了
public void menu(){
System.out.println("***********************************************");
System.out.println("***************欢迎登录员工管理系统**************");
System.out.println("***********************************************");
System.out.println("1、输入添加员工信息");
System.out.println("2、查询所有员工信息");
System.out.println("3、根据部门查询员工信息");
System.out.println("4、查询某一个工资区间内的员工信息");
System.out.println("5、根据工龄查询员工信息");
System.out.println("6、根据id删除员工信息");
System.out.println("7、根据部门删除员工信息");
System.out.println("8、根据工号更改员工部门或者薪资信息");
System.out.println("9、根据工号查询员工信息");
System.out.println("0、退出");
System.out.println("***********************************************");
System.out.println("你要执行哪个操作?");
int num = scanner.nextInt();
switch(num){
case 1:
add();
//因为我们每次都要回到菜单,所以我们可以在这里调用当前的方法,但是一定要有方法的停止
menu();
break;
case 2:
findAll();
menu();
break;case 3:
findByDept();
menu();
break;
case 4:
findSalary();
menu();
break;
case 5:
findByWorkYear();
menu();
break;
case 6:
deleteByEid();
menu();
break;
case 7:
deleteByDept();
menu();
break;
case 8:
updateByEid();
menu();
break;
case 9:
findByEid();
menu();
break;
case 0:
System.exit(0);//退出系统关闭虚拟机
break;
default:
System.out.println("你输入的信息有误,请重新输入:");
menu();
}
}
}
public class EmpTest {
public static void main(String[] args) {
EmpDao empDao = new EmpDao();
empDao.menu();
}
}3、练习题存在的问题
根据一个年份一个月份显示当前月份的日历布局,就电脑右下角的日历样式
package com.test_01;
import java.util.Scanner;
/**
* 1、根据一个年份一个月份显示当前月份的日历布局,就电脑右下角的日历样式
*/
public class Calendar {
Scanner scanner = new Scanner(System.in);
//定义一个方法，判断一个年份是平年还是闰年
public boolean isLeapYear(int year) {
//int year = scanner.nextInt();
boolean flag = false;
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
flag = true;
}
return flag;
}
//定义一个方法,输入年份和月份,判断这个月有几天
public int getDay(int year, int month) {
int day = 0;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
day = 31;
break;
case 4:
case 6:
case 9:
case 11:
day = 30;
break;
case 2:
if (isLeapYear(year)) {
day = 29;
} else {
day = 28;
}
break;
default:
System.out.println("输入的月份有误");
break;
}
return day;
}
//定义一个方法,计算从1900年1月1日~ year年month月之间的总天数.不包含当前的年份和月份
public int totalDay(int year, int month) {
int total = 0;
//先算整年的
for (int i = 1900; i < year; i++) {
if (isLeapYear(i)) {
total += 366;
} else {
total += 365;
}
}
//再算整月的
for (int i = 1; i < month; i++) {
total += getDay(year, i);
}
return total;
}
//打印日历格式,并且计算,总天数对七进行求余,余数是多少
public void print() {
System.out.println("请输入一个年份");
int year = scanner.nextInt();
System.out.println("请输入一个月份");
int month = scanner.nextInt();
int num = totalDay(year, month);
System.out.println(year + "年\t" + month + "月\t");
System.out.println("一\t二\t三\t四\t五\t六\t日");
//用来计数打印了几个元素了，实现每七个换一行
int index = 0;
//打印空格
for (int i = 1; i <= num % 7; i++) {
System.out.print(" \t");
index++;
}
//System.out.println("index = "+index);
//打印日期
for (int i = 1; i <= getDay(year, month); i++) {
System.out.print(i + "\t");
index++;
if (index % 7 == 0) {
System.out.println();
}
}
System.out.println();
}
}
package com.test_01;
public class CalendarTest {
public static void main(String[] args) {
Calendar calendar = new Calendar();
calendar.print();
}
}三、类之间的关系、面对对象三大特征之一之继承、游离块、static、final关键字
1、类之间的关系：横向关系
从表现形式上是完全相同的,都是一个类作为另外一个类的属性存在
组合关系:相对来说不是那么紧密
比如:人喝水
人:主要参与到事件中元素
水杯:辅助执行的内容
聚合关系:必须有另外一个类的参与才能完成
比如:汽车和发动机
纵向关系
继承extends
实现implements
2、面对对象三大特征之一之继承
继承的表现形式是:
就是将元素的相同的内容抽取出来,放在一个类中,其余的类写自己独特具有的元素,然后继承于这个公共类。
子类能够继承父类中非私有的属性和方法,但是构造函数虽然是public修饰的,不能被子类继承。
因为父类的构造函数是用来创建对象的,如果子类能够继承父类的构造函数就相当于子类能够创建一个父类对象.简
单说:儿子能给自己找个爹
好处:
一个父类可以有多个子类,所有共用的元素可以全部放在父类中,不需要重复的去写,并且子类也可以直接调用。
缺点:
增加了代码之间的耦合性
对于程序设计而言,我们要做到:高内聚,低耦合
耦合:类与类,元素与元素之间的关联性,比如如果父类中的方法被修改了,子类就必须接受这个修改之后的内容
重要提示:
一个父类可以有多个子类,但是一个子类只能有一个父类
继承的特点:
1、子类能够继承父类中非私有的属性和方法
2、一个父类可以有多个子类
3、一个子类只能有一个父类但是,一个类A是类B的父类的同时,可以是类C的子类
继承关系中不可以多继承但是可以多层继承
当两个类存在继承关系的时候,创建对象的时候,会先执行父类的构造函数,创建父类对象然后再执行子类的构造函数
this:调用本类中的内容
super:当两个类之间存在继承关系的时候，调用父类中的元素
如果子类和父类中出现了相同名字的元素:
变量:
子类会调用自己的变量,不会调用父类的
方法:
子类会调用自己的方法,如果子类的方法和父类的方法名相同,但是返回值类型不同,子类中的方法会报错
方法的重载和重写
重载:发生在同一个类中
方法名相同,参数列表不同
参数列表不同:参数的个数,参数的类型,参数的顺序不同
重写:发生在存在继承关系的子类中
子类重写父类的方法
三同:方法名相同,参数列表相同,返回值类型相同
一不严格:子类中方法的访问控制修饰符不能比父类严格
3、游离块：
游离块是一种特殊的方法,和类属于一个级别,只要这个类被调用了,无论是否创建对象,是否调用构造函数进行对
象的创建,都会执行这个游离块的内容
语法:
{
内容
}
游离块的执行:
当存放游离块的类被调用的时候,会在执行所有的内容执行之前先执行游离块的内容
public class Demo_ylk {
{
System.out.println("④游离块1");
}
public Demo_ylk(){
System.out.println("①构造函数");
}
public void m1(){System.out.println("②普通方法");
}
{
System.out.println("③游离块2");
}
}
public class Demo_ylk_2 extends Demo_ylk{
public Demo_ylk_2(){
System.out.println("子类的构造器");
}
{
System.out.println("子类中的游离块1");
}
public void m1(){
System.out.println("子类中重写了父类的方法");
}
{
System.out.println("子类中的游离块2");
}
}
public class Test {
public static void main(String[] args) {
Demo_ylk_2 demo_ylk_2 = new Demo_ylk_2();
demo_ylk_2.m1();
}
}静态游离块特点:
如果存在继承关系的两个类中,都有静态游离块,那么执行的顺序是:
父类中的静态游离块
子类中的静态游离块
父类中的游离块
父类中的构造方法
子类中的游离块
子类中的构造方法
子类中的普通方法
当我们有多个对象的时候,普通的游离块每次创建对象的时候都会执行,但是静态游离块中的内容执行一次
4、static关键字
意思是静态的, 但是凡是用static修饰的元素都代表全局的
如果一个方法是static修饰的,那么它要调用的方法或者成员变量也要是static修饰的,或者说你可以对其进行
创建对象之后进行赋值。
如果一个方法是没有使用static修饰的普通方法,想要调用static修饰的成员变量或者成员方法是可以进行处理
的。
属性:如果使用static进行属性的修饰,那么一旦这个元素被赋值了,后面所有的元素在使用的时候都是初始赋上
去的值。其中如果有一个对象将静态属性的值改变了,那么后面的获取到的都不是最初始的值
调用静态的元素的时候,可以并且推荐:直接使用类名进行调用
类名.属性名= 赋值;
类名.方法名();
静态方法:
java中支持使用static进行修饰成员方法,就是静态方法。与它相对应的是没有使用static修饰的方法也就是普
通方法。
与静态的成员变量一样,这个方法也是属于类本身的,不是属于某一个对象的。静态成员方法不需要创建对象就可以
直接调用,非静态成员方法就必须创建对象之后才能进行使用。
静态的成员方法不能使用this和super关键字，也不能调用非静态的成员方法。
5、final关键字：
可以修饰:
类: 被final修饰的类不能被继承
属性: 被final修饰的属性不能再被赋值,所以我们在定义这个属性的时候必须给其符初始值,因为不能被改变了.所以叫常量.整个单词的字母全部大写
方法: 被final修饰的方法不能被重写
四、可变长参数、递归、Java中的内存分配
1、可变长参数
可变长参数:
一般用在对对象进行赋值或者接收到从前端传过来的信息上
因为用户提交的信息可能是不完全的,可能出现参数个数不同的情况
并且从前端传过来的信息都是String类型,所以我们可以使用一个可
变长的参数来对元素进行处理
当我们定义一个可变长参数的方法的时候,我们只要确定传入参数的数据类型
和方法需要的参数类型是一致,那么就可以传多个参数进来,并且在方法中
最终以数组的形式进行处理
可变长参数不能够在后面继续添加别的参数,因为在给参数进行赋值的过程中,我们
无法确定,哪个值是给参数的
当你定义方法的时候,方法参数列表中的值,是形式参数,我们叫形参
当你调用方法的时候,在方法括号中添加的参数叫实际参数,我们叫实参
2、递归
(1)概念:
方法直接或者间接的方式调用自己本身,这样的形式称为递归
(2)递归的三要素:
1、要有边界条件,也就是停止递归的条件
2、有点像循环,递归前进段,每次都对条件做出改变,调用执行自己本身
3、要有递归返回段,要将程序执行的返回值返回(要是你在综合类项目中,自己调用方法
自己本身的话,只要给它进行停止,如果每次执行的内容相同,可以没有前进段和返回段,
如果想要计算重复计算之后的值,那么就需要将递归进行和返回段控制)
(3)如何使用递归:
1、根据题目需求定义一个方法
-- 分析,参数和返回值的类型
2、找到边界条件(找到什么时候不递归)
3、写分支条件
if(边界条件){
执行返回段
}else{
执行前进段(调用自己的方法)三、java内存分配
}
3、java内存分配
java程序运行的时候,需要在内存中分配空间,为了提高执行的效率,对内存空间进行了不同区域划分,因为每个区域都
有特定的处理数据的方式和内存管理方式
栈:
分为栈顶和栈底,所有的元素都是在栈顶进行操作的
比如:手枪弹夹一样,第一颗被压进去的子弹,最后一颗被打出来
相当于入口和出口是相同的
特点:先进后出
1 2 3 4 5 6 7
队列:
一端进行插入操作,另外一端执行删除操作
像上车排队一样,所有的元素是在尾部添加进去,从队列头部出来
特点:先进先出
4、练习题--电器商城小系统作业
自己的：
package com.j2301.work;
/**
* 商品类
*/
public class Commodity {
private String sid;//商品编号
private String sName;//商品名称
private double price;//商品价格
private int inventory;//商品库存
public Commodity() {
}
public Commodity(String sid, String sName, double price, int inventory) {
this.sid = sid;
this.sName = sName;
this.price = price;
this.inventory = inventory;
}
public String getSid() {
return sid;
}
public void setSid(String sid) {
this.sid = sid;
}
public String getsName() {
return sName;
}
public void setsName(String sName) {
this.sName = sName;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getInventory() {
return inventory;
}
public void setInventory(int inventory) {
this.inventory = inventory;
}
@Override
public String toString() {
return "Commodity{" +
"sid='" + sid + '\'' +
", sName='" + sName + '\'' +
", price=" + price +
", inventory=" + inventory +
'}';
}
}
package com.j2301.work;
public class User {
private String userName;//用户名
private String passWord;//用户密码
private String otherName;//用户别名
private int age;//用户年龄
public User() {
}
public User(String userName, String passWord, String otherName, int age) {
this.userName = userName;
this.passWord = passWord;
this.otherName = otherName;
this.age = age;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getOtherName() {
return otherName;
}
public void setOtherName(String otherName) {
this.otherName = otherName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"userName='" + userName + '\'' +
", passWord='" + passWord + '\'' +
", otherName='" + otherName + '\'' +
", age=" + age +
'}';
}
}
package com.j2301.work;
import java.util.ArrayList;
import java.util.Scanner;
/**
* 实现用户注册和用户登录的类，以及实现功能的类，所有功能实现方法所在的类
*/
public class UserMethod {
ArrayList<Commodity> cds = new ArrayList<Commodity>();
ArrayList<User> users = new ArrayList<User>();
ArrayList<Commodity> cds1 = new ArrayList<Commodity>();
static String uName = null;
Scanner sc = new Scanner(System.in);
//用户注册
public void addUser() {
System.out.println("请输入用户名");
String name = sc.next();
boolean flag = true;
for (int i = 0; i < users.size(); i++) {
if (users.get(i).getUserName().equals(name)) {
System.out.println("用户名已存在");
addUser();
flag = false;
}
}
if (flag) {
while (true) {
User user = new User();
user.setUserName(name);
System.out.println("请输入密码");
String passWord = sc.next();
char[] arr = passWord.toCharArray();
if (arr.length >= 6) {
System.out.println("请再次输入密码以确认");
String passWord1 = sc.next();
if (passWord1.equals(passWord)) {
user.setPassWord(passWord);
System.out.println("请输入昵称");
String otherName = sc.next();
user.setOtherName(otherName);
while (true) {
System.out.println("请输入您的年龄");
int age = sc.nextInt();
if (age > 0 && age <= 100) {
user.setAge(age);
users.add(user);
System.out.println("恭喜您注册成功");
break;
} else {
System.out.println("您输入的年龄必须是0-100之间的数字！");
}
}
break;
} else {
System.out.println("两次密码不一致，重新输入");
}
} else {
System.out.println("输入的密码长度有误，重新输入");
}
}
}
}
//用户登录
public void login() {
while (true) {
System.out.println("请输入用户名");
String name = sc.next();
boolean flag = false;
for (int i = 0; i < users.size(); i++) {
if (users.get(i).getUserName().equals(name)) {
flag = true;
while (true) {
System.out.println("请输入密码");
String passWord = sc.next();
if (users.get(i).getPassWord().equals(passWord)) {
System.out.print("登录成功");
uName = users.get(i).getUserName();
System.out.println("您好：" + users.get(i).getUserName());
break;
} else {
System.out.println("密码错误，重新输入");
}
}
}
}
if (flag) {
break;
} else {
System.out.println("输入的用户名不存在,重新输入");
}
}
}
//用户操作登录注册页面
public void menu() {
System.out.println("*************************电器商城***************************");
System.out.println("\t\t\t\t\t\t" + "1、用户登录");
System.out.println("\t\t\t\t\t\t" + "2、用户注册");
System.out.println("\t\t\t\t\t\t" + "3、退出系统");
System.out.println("*************************电器商城***************************");
System.out.println("请输入菜单");
int number01 = sc.nextInt();
switch (number01) {
case 1:
login();
menu01();
break;
case 2:
addUser();
menu();
break;
case 3:
break;
default:
System.out.println("您输入的序号有误，请重新输入");
menu();
}
}
//用户登录成功后的操作页面
public void menu01() {
System.out.println("*************************电器商城***************************");
System.out.println("\t\t\t\t\t\t" + "1、商品购买");
System.out.println("\t\t\t\t\t\t" + "2、我的购物车");
System.out.println("\t\t\t\t\t\t" + "3、个人信息");
System.out.println("\t\t\t\t\t\t" + "4、注销");
System.out.println("*************************电器商城***************************");
System.out.println("请输入菜单：");
int number = sc.nextInt();
switch (number){
case 1:
buy();
menu01();
break;
case 2:
shoppingCart();
menu01();
break;
case 3:
message();
menu01();
break;
case 4:
menu();
break;
default:
System.out.println("输入的序号有误");
}
}
//商品添加
public void add() {
cds.add(new Commodity("10101", "海尔冰箱", 3999.9, 50));
cds.add(new Commodity("10102", "格力冰箱", 2888.8, 30));
cds.add(new Commodity("10103", "TCL冰箱", 1999.8, 100));
cds.add(new Commodity("10104", "美的冰箱", 4999.9, 60));
cds.add(new Commodity("10201", "海尔空调", 3099.9, 50));
cds.add(new Commodity("10202", "格力空调", 2808.8, 40));
cds.add(new Commodity("10203", "TCL空调", 1099.8, 120));
cds.add(new Commodity("10204", "美的空调", 4909.9, 65));
}
//遍历所有商品
public void bl() {
System.out.println("商品编号\t\t商品名称\t\t商品价格\t\t商品库存");
for (int i = 0; i < cds.size(); i++) {
System.out.println(cds.get(i).getSid() + "\t\t" + cds.get(i).getsName() + "\t\t" + cds.get(i).getPrice() +
"\t\t" + cds.get(i).getInventory());
}
}
//1、商品购买
public void buy() {
bl();
while (true) {
System.out.println("请输入商品编号：");
String id = sc.next();
boolean flag = false;
for (int i = 0; i < cds.size(); i++) {
if (cds.get(i).getSid().equals(id)) {
flag = true;
while (true) {
System.out.println("请输入购买数量：");
int num = sc.nextInt();
if (num > 0 && num <= cds.get(i).getInventory()) {
cds1.add(new Commodity(cds.get(i).getSid(), cds.get(i).getsName(), cds.get(i).getPrice(), num));
System.out.println("您还要继续购买吗？(是y 否 任意键)");
String m = sc.next();
if (m.equals("y")) {
buy();
}
break;
} else if (num > cds.get(i).getInventory()) {
System.out.println("购买数量必须小于" + cds.get(i).getInventory());
} else {
System.out.println("购买数量不能为0或者为负数");
}
}
}
}
if (flag) {
break;
} else {
System.out.println("请重新输入商品编号");
}
}
}
//2、购物车信息和功能
public void shoppingCart(){
System.out.println("商品编号\t\t商品名称\t\t商品价格\t\t商品库存");
double sum=0;
for (int i = 0; i < cds1.size(); i++) {
System.out.println(cds1.get(i).getSid() + "\t\t" + cds1.get(i).getsName() + "\t\t" + cds1.get(i).getPrice() +
"\t\t" + cds1.get(i).getInventory());
sum+=cds1.get(i).getPrice() * cds1.get(i).getInventory();
}
System.out.println("总金额为："+sum);
System.out.println("您是否付款？(是y 否 任意键)");
String m = sc.next();
if (m.equals("y")) {
while (true) {
System.out.println("请输入付款金额：");
double price = sc.nextDouble();
if (price >= sum) {
System.out.println("找零" + (price - sum));
for (int i = 0; i < cds.size(); i++) {
for (int j = 0; j < cds1.size(); j++) {
if (cds.get(i).getSid().equals(cds1.get(j).getSid())) {
cds.get(i).setInventory(cds.get(i).getInventory()-cds1.get(j).getInventory());
}
}
}
cds1.clear();
break;
} else {
System.out.println("金额不足");
}
}
}
}
//3、个人信息展示
public void message(){
for (int i = 0; i < users.size(); i++) {
if (users.get(i).getUserName().equals(uName)){
System.out.println("*****************************您的个人信息****************************");
System.out.println("\t\t\t\t\t用户名："+uName);
System.out.println("\t\t\t\t\t昵称："+users.get(i).getOtherName());
System.out.println("\t\t\t\t\t年龄："+users.get(i).getAge());
}
}
}
}
package com.j2301.work;
public class Test {
public static void main(String[] args) {
UserMethod userMethod = new UserMethod();
userMethod.add();
userMethod.menu();
}
}
标准的：
package com.电器商城小系统;
import java.util.ArrayList;
import java.util.List;
/**
* 数据存储区
*
* @author Arvin
*
*/
public class DataProvider {
/*public static List<User> userList = new ArrayList<User>();// 保存用户列表的数据源
public static List<Product> proList = new ArrayList<Product>();// 保存商品列表数据源
public static List<Product> carList = new ArrayList<Product>();// 保存购物车商品列表数据源
public static User currentUser = null;
public static void initData() {
proList.add(new Product("10101", "海尔冰箱", 3999.9, 50));
proList.add(new Product("10102", "格力冰箱", 2888.8, 30));
proList.add(new Product("10103", "TCL冰箱", 1999.8, 100));
proList.add(new Product("10104", "美的冰箱", 4999.9, 60));
proList.add(new Product("10201", "海尔空调", 3099.9, 50));
proList.add(new Product("10202", "格力空调", 2808.8, 40));
proList.add(new Product("10203", "TCL空调", 1099.8, 120));
proList.add(new Product("10204", "美的空调", 4909.9, 65));
userList.add(new User("admin", "123456", "张三", 24));
}*/
public static void main(String[] args) {
List<User> userList = new ArrayList<User>();// 保存用户列表的数据源
List<Product> proList = new ArrayList<Product>();// 保存商品列表数据源
List<Product> carList = new ArrayList<Product>();// 保存购物车商品列表数据源
List<User> userRegList = new ArrayList<User>();// 保存用户登录列表
proList.add(new Product("10101", "海尔冰箱", 3999.9, 50));
proList.add(new Product("10102", "格力冰箱", 2888.8, 30));
proList.add(new Product("10103", "TCL冰箱", 1999.8, 100));
proList.add(new Product("10104", "美的冰箱", 4999.9, 60));
proList.add(new Product("10201", "海尔空调", 3099.9, 50));
proList.add(new Product("10202", "格力空调", 2808.8, 40));
proList.add(new Product("10203", "TCL空调", 1099.8, 120));
proList.add(new Product("10204", "美的空调", 4909.9, 65));
userList.add(new User("admin", "123456", "张三", 24));
HomeScreen hs = new HomeScreen();
while(true){
hs.menu(userList,proList,carList,userRegList);
}
}
}
package com.电器商城小系统;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class HomeScreen {
/**
* 主菜单
*/
public static void menu(List<User> userList, List<Product> proList, List<Product> carList, List<User> userRegList) {
System.out.println("**********************电器商城*************************");
System.out.println(
" 1.用户登录 ");
System.out.println(
" 2.用户注册 ");
System.out.println(
" 3.用户列表 ");
System.out.println(
" 4.退出系统 ");
System.out.println("****************************************************");
Scanner sc = new Scanner(System.in);
System.out.println("请输入菜单：");
int index = sc.nextInt();
switch (index) {
case 1:
// 登陆
register(userList, proList, carList, userRegList);
break;
case 2:
// 注册
login(userList);
break;
case 3:
// 列表
userInfo(userList);
break;
case 4:
// 退出
System.exit(0);
break;
}
}
/**
* 命令界面
*/
public static void command(List<User> userList, List<Product> proList, List<Product> carList,List<User> userRegList) {
System.out.println("**********************电器商城*************************");
System.out.println(
" 1.商品购买 ");
System.out.println(
" 2.我的购物车 ");
System.out.println(" 3.个人信息 ");
System.out.println(
" 4.注销 ");
System.out.println("****************************************************");
Scanner sc = new Scanner(System.in);
System.out.println("请输入菜单：");
int index = sc.nextInt();
while (true) {
switch (index) {
case 1:
// 商品购买
buyList(userList, proList, carList, userRegList);
break;
case 2:
// 我的购物车
shopCar(userList, proList, carList, userRegList);
break;
case 3:
// 个人信息
info(userList,proList, carList,userRegList);
break;
case 4:
// 注销
System.exit(0);
System.out.println("注销成功~");
break;
}
}
}
/**
* 用户注册
*/
public static void login(List<User> userList) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String userName = sc.nextLine();
if (!isSave(userList, userName)) {
System.out.println("请输入密码：");
String passWord = sc.nextLine();
while (!passWord.matches("[a-zA-Z0-9_]{6,15}")) {
System.out.println("密码长度不得小于6位");
System.out.println("请输入密码：");
passWord = sc.nextLine();
}
System.out.println("请再次输入密码：");
String pwd = sc.nextLine();
while (!passWord.equals(pwd)) {
System.out.println("两次输入密码不一致~");
System.out.println("请输入密码：");
passWord = sc.nextLine();
System.out.println("请再次输入密码：");
pwd = sc.nextLine();
}
System.out.println("请输入年龄：");
int age = sc.nextInt();
while (age < 0 || age > 100) {
System.out.println("您输入的年龄必须是1——100之间的数字~");
System.out.println("请重新输入年龄~");
age = sc.nextInt();
}
System.out.println("请输入昵称：");
String otherName = sc.next();
userList.add(new User(userName, passWord, otherName, age));
System.out.println("注册成功~");
} else {
System.out.println("用户名已存在，不能重复添加~");
}
}
/**
* 显示已添加用户的列表
*/
public static void userInfo(List<User> userList) {
System.out.println("用户名\t密码\t年龄\t昵称");
for (User u : userList) {
System.out.println(u.toString());
}
}
/**
* 用户登录
*/
public static void register(List<User> userList, List<Product> proList, List<Product> carList,
List<User> userRegList) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");
String userName = sc.next();
System.out.println("请输入密码：");
String pwd = sc.next();
for (int i = 0; i < userList.size(); i++) {
if (userList.get(i).getPassword().equals(pwd)) {
System.out.println("登录成功！");
System.out.println("**********************电器商城*************************");
System.out.println("您好~：" + userList.get(i).getUserName());
int age = userList.get(i).getAge();
String otherName = userList.get(i).getOtherName();
userRegList.add(new User(userName, pwd, otherName, age));
command(userList, proList, carList, userRegList);
} else {
System.out.println("您输入的用户名或密码错误，请重新登录！");
}
}
}
/**
* 判断用户是否已经存在
*/
public static boolean isSave(List<User> userList, String userName) {
boolean flag = false;
for (int i = 0; i < userList.size(); i++) {
if (userList.get(i).getUserName().equals(userName)) {
flag = true;
}
}
return flag;
}
/**
* 商品列表
*/
public static void buyList(List<User> userList, List<Product> proList, List<Product> carList,
List<User> userRegList) {
System.out.println("**********************电器商城*************************");
System.out.println("商品编号\t商品名称\t商品价格\t商品库存");
for (Product product : proList) {
System.out.println(product);
}
buy(userList, proList, carList);
while (true) {
Scanner sc = new Scanner(System.in);
System.out.println("您还需要继续购买吗？(是 【Y】 否 【任意键】)");
String msg = sc.next();
char ch = msg.charAt(0);
switch (ch) {
case 'Y':
buy(userList, proList, carList);
break;
default:
command(userList, proList, carList, userRegList);
System.out.println("**********************电器商城*************************");
break;
}
}
}
/**
* 购买商品
*/
public static void buy(List<User> userList, List<Product> proList, List<Product> carList) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入商品编号：");
String id = sc.next();
while (!isSavePro(proList, id)) {
System.out.println("您输入的商品编号不存在~");
System.out.println("请输入商品编号：");
id = sc.next();
}
System.out.println("请输入购买数量：");
int num = sc.nextInt();
while (num < 0) {
System.out.println("购买数量不能为零或者为负数~");
System.out.println("请输入购买数量~");
num = sc.nextInt();
}
String name = null;
double price = 0.0;
int stock = 0;
for (int i = 0; i < proList.size(); i++) {
if (proList.get(i).getId().equals(id)) {
name = proList.get(i).getName();
price = proList.get(i).getPrice();
stock = proList.get(i).getStock();
while (num > stock) {
System.out.println("购买数量必须小于库存~");
System.out.println("请输入购买数量~");
num = sc.nextInt();
}
proList.set(i, new Product(id, name, price, stock - num));
carList.add(new Product(id, name, price, num));
}
}
}
/**
* 判断商品编号是否存在商品列表中
*/
public static boolean isSavePro(List<Product> proList, String id) {
boolean flag = false;// 默认不存在
for (int i = 0; i < proList.size(); i++) {
if (proList.get(i).getId().equals(id)) {
flag = true;
}
}
return flag;
}
/**
* 购物车
*/
public static void shopCar(List<User> userList, List<Product> proList, List<Product> carList,
List<User> userRegList) {
System.out.println("**********************电器商城*************************");
System.out.println("商品编号\t商品名称\t商品价格\t购买数量");
double sumMoney = 0.0;
for (int i = 0; i < carList.size(); i++) {
System.out.println(carList.get(i));
sumMoney += carList.get(i).getPrice() * carList.get(i).getStock();
}
System.out.println("总金额为：" + sumMoney + "元");
System.out.println("您是否付款？(是 【Y】 否 【任意键】)");
Scanner sc = new Scanner(System.in);
String msg = sc.next();
char ch = msg.charAt(0);
switch (ch) {
case 'Y':
System.out.println("请输入付款金额:");
double money = sc.nextDouble();
while (money < sumMoney) {
System.out.println("请输入付款金额:");
money = sc.nextDouble();
}
double moreMoney = money - sumMoney;
System.out.println("找零：" + moreMoney + "元");
int sum = carList.size();
//for (int i = sum-1; i >=0; i--) {
//while(!carList.isEmpty()){
while(!carList.isEmpty()){
carList.remove(0);
//carList.clear();
}
break;
default:
command(userList, proList, carList, userRegList);
break;
}
}
/**
* 个人信息
*/
public static void info(List<User> userList, List<Product> proList, List<Product> carList,
List<User> userRegList) {
if (!userRegList.isEmpty()) {
System.out.println("**********************电器商城*************************");
String name = userRegList.get(0).getUserName();
int age = userRegList.get(0).getAge();
String otherName = userRegList.get(0).getOtherName();
System.out.println("用户名:" + name);
System.out.println("年龄:" + age);
System.out.println("昵称:" + otherName);
command(userList, proList, carList, userRegList);
}
}
}
package com.电器商城小系统;
public class Product {
private String id;//商品编号
private String name;//商品名称
private double price;//商品单价
private int stock;//商品库存
public Product() {
}
public Product(String id, String name, double price, int stock) {
super();
this.id = id;
this.name = name;
this.price = price;
this.stock = stock;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getStock() {
return stock;
}
public void setStock(int stock) {
this.stock = stock;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
long temp;
temp = Double.doubleToLongBits(price);
result = prime * result + (int) (temp ^ (temp >>> 32));
result = prime * result + stock;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Product other = (Product) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(price) != Double.doubleToLongBits(other.price))
return false;
if (stock != other.stock)
return false;
return true;
}
@Override
public String toString() {
return id + "\t" + name + "\t" + price + "\t" + stock;
}
}
package com.电器商城小系统;
public class User {
private String userName;
private String password;
private String otherName;
private int age;
public User(){
}
public User(String userName, String password, String otherName, int age) {
super();
this.userName = userName;
this.password = password;
this.otherName = otherName;
this.age = age;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getOtherName() {
return otherName;
}
public void setOtherName(String otherName) {
this.otherName = otherName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + ((otherName == null) ? 0 : otherName.hashCode());
result = prime * result + ((password == null) ? 0 : password.hashCode());
result = prime * result + ((userName == null) ? 0 : userName.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
if (age != other.age)
return false;
if (otherName == null) {
if (other.otherName != null)
return false;
} else if (!otherName.equals(other.otherName))
return false;
if (password == null) {
if (other.password != null)
return false;
} else if (!password.equals(other.password))
return false;
if (userName == null) {
if (other.userName != null)
return false;
} else if (!userName.equals(other.userName))
return false;
return true;
}
@Override
public String toString() {
return userName + "\t" + password + "\t" + age + "\t" + otherName;
}
}
五、静态、抽象类、接口的简单了解和基本运用
1、静态
静态变量和非静态变量之间的区别
静态变量:被static修饰的变量,是类变量
非静态变量:没有被static修饰的变量,叫实例变量 属性也是 方法中的局部变量也是
两者之间的区别:
对于静态变量在内存中只有一个拷贝,jvm(java虚拟机)只为静态变量分配一次内存,在类进行加载的过程中完成
内存的分配,可以使用类名进行直接调用(比较方便).也可以通过对象名来进行访问。(但是不建议使用,因为会报警
告)。静态属性是属于类的,所以属性是可以共享的。
对于非静态变量,每次在堆中创建一次对象,就会分配一个内存,非静态变量可以在内存中进行多次的拷贝,相互之
间不影响。那么属性就是自己的.
静态方法和非静态方法
区别1:
static修饰的方法是静态方法(类方法)
没有使用static修饰的方法,是非静态方法(实例方法)
区别2:
调用方式不同
静态方法可以并且建议直接使用类名进行调用
非静态方法必须创建对象之后才能使用
区别3:
内部元素成分
静态方法中,只能访问静态的属性和方法.不能使用this和super关键字
非静态方法中,什么都可以调用,包括静态方法,也可以使用this和super
2、抽象类：
(1)什么是抽象类?
就是使用abstract修饰的类
public abstract class 类名{
//全局变量
//普通方法
//构造函数
//抽象方法
}
(2)特点:
不能够直接使用抽象类创建对象,必须使用子类继承,并且实现父类(抽象类中)没有实现的方法
通过子类来创建对象
(3)什么情况下来定义抽象类
当类中有抽象方法的时候
当子类继承一个抽象类的时候,不想实现抽象类中的抽象方法,则可以添加abstract变为抽象类
当一个类实现了一个接口,不能实现接口中所有的抽象方法的时候
(4)抽象方法格式:
public abstract <返回值的数据类型> 方法名(参数列表);
没有方法体,也没有大括号三、接口
不能和private static final关键字一起使用
(5)什么时候把类定义成抽象的?
(1)当不知道一个方法具体的算法的时候,就把这个方法定义成抽象的
(2)抽象方法必须定义在抽象类中
(6)当编写一个类的时候,我们需要在类中定义方法,方法使用来描述这个类中有哪些功能,方法就是功能的具体实现。
这些方法有具体的实现,但是当链各个类存在继承关系,某一个父类只知道这个子类应该包含一个功能,但是无法准
确的去处理这个方法应该如何执行,那么就可以定义成抽象的。
把父类定义成一个抽象类,让子类必须实现这个方法,但是具体的实现内容由子类自己决定
(7)语法:
public abstract class 类名{
//全局变量
//普通方法
//构造函数
//抽象方法
}
public abstract 返回值的类型 方法名(参数列表);//只有方法的声明没有方法的具体实现
final:最终,final修饰的方法代表子类能不够重写这个方法
static:静态的方法,静态方法是属于整个类的
private:私有的方法,子类无法继承(子类根本看不到有这个方法),不能重写,而abstract和private一起使用的话,
abstract修饰的方法需要被子类重写,private修饰的方法子类又看不到,存在冲突
(8)特点:
1、抽象类和抽象方法都是使用abstract进行修饰的
2、抽象类可以继承抽象类
3、抽象类也可以继承于一个普通的类
4、抽象类不可以被实例化(创建对象),因为实例化之后没有意义
5、只有实现父类(抽象类)中所有的抽象方法,其子类才可以进行实例化,否则子类也必须是一个抽象类
原因:之所以想要把一个类定义成抽象类,更多的是在编程的思想,使面向对象的操作更加简单
6、抽象类可以没有抽象方法,但是没有抽象方法的抽象类没有意义
7、抽象类中可以有构造函数,但是我们不去使用他,因为没有办法创建对象
5、抽象类一定是父类么?
是的,因为是在其他的类和功能中将其要实现的内容不断抽取出来的,一般把有共性和一些子类都有的方法放在抽象
类中。但是子类中具体的实现是不一样的,这些方法在父类中就会被定义成抽象方法
6、抽象类中是否可以不定义抽象方法?
可以,但是一个没有抽象方法的抽象类,没有意义,就是不能创建对象罢了
3、接口：
类:
变量(静态变量,非静态变量)
常量
方法(静态方法,非静态方法)
构造函数
游离块(静态游离块)
内部类
抽象类:
抽象方法
普通方法
构造函数(一般不用)
游离块(静态游离块)变量(静态变量,非静态变量)
常量
接口:
常量默认:public static final 数据类型 常量名;
抽象方法默认:public abstract 返回值类型 方法名(参数列表);
从jdk1.8以后可以定义 静态方法和default方法,可以有实现(用得少)
接口:
接口是功能的集合,同样也是引用数据类型,是比抽象更抽象的"类",不是使用class进行定义的
接口只描述应该具备的方法,没有方法的具体实现
接口是一种身份的象征
4、拓展：
文件和文件之间的关系:
1、接口和接口之间可以继承,并且是多继承
public interface C extends B,A{
}
2、接口和类之间
如果一个类实现了一个接口,就要实现接口中所有的抽象方法,如果不想实现,那么这个类就必须是抽象类,由子类
来进行实现。
如果一个类实现了一个接口,但是实现的接口还继承了别的接口,那么这个实现类要实现所有的抽象方法
接口不能够继承于一个普通的类,也不能继承于抽象类
特点:
1、接口中定义的变量是常量,值不可以被改变。
如果是基本数据类型的常量,值不可以被改变
如果是引用数据类型的常量,地址不可以被改变
2、接口中定义的方法可以省略去abstract不写
3、接口不可以创建对象
4、实现类必须实现接口中所有的抽象方法才能创建对象,如果不想实现,这个类就必须是抽象类
5、类与类之间:单继承 一个子类只能有一个父类
类与接口之间:多实现, 类 implements 接口1,接口2... 一个实现类可以实现多个接口
接口和接口之间:多继承, 一个接口可以有多个父接口
一个类继承于一个父类的同时还可以实现多个接口
为什么要定义接口?
原因:
接口可以解决单继承的问题
一个类可以同时实现多个父接口,父类中定义事物的基本功能,接口定义事务的扩展功能
好处:
接口的出现,降低了设备与设备之间的耦合性
接口的出现方便了后期的维护
一方是使用接口
一方是实现接口
5、接口和抽象类之间的区别:
相同点:
都位于继承的顶端,用于被其他的类实现或者继承
都不能创建对象
都可以定义抽象方法,子类都能够实现这些抽象方法
不同点:
| 抽象类 | 接口 |
声明关键字 | abstract class | Interface |
内部成员 | 普通类能定义的其都能，还能定义抽象方法 | 只能定义常量、抽象方法和default和static修饰的方法 |
抽象方法 | 必须用abstract修饰 | 抽象的关键字可以不用写 |
和类的关系 | 单继承 | 多实现 |
抽象类和接口选择谁:
优先选择接口,尽量少使用抽象类,最为理想的设计:所有的"定义"和"实现"分离
接口是单纯的抽象接口
扫一扫
16万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
