我的Java学习笔记
抽象与接口
文章目录
抽象类和接口
1.类和对象的关系?
类就是对对象的描述。如果一个类中无法充足的描述一个对象那么这么类就是抽象类。
2.abstract关键字
2.1 修饰类
使用abstract修饰类称之为抽象类。
抽象类中可以包含哪些元素?
1.抽象方法 2.构造方法 3.变量 4.常量 5.普通方法 6.静态方法
抽象类的用法?
以前:抽象类不能被实例化,抽象类一般当成父类来进行使用。子类继承了抽象类就要必须重写父类的抽象方 法
现在:抽象类可以实例化,但是一般不会这样使用。如果子类是抽象类 继承父类。那么可以不重写父类抽象方法
为什么抽象类继承抽象类可以不重写抽象方法?
普通类之所以需要重写抽象方法是因为普通类中不能容纳抽象方法。但是抽象类中可以包含抽象方法,所以可以不重写。
2.2 修饰方法
使用abstract修饰方法称之为抽象方法。
抽象方法和普通方法的区别?
1.抽象方法只有方法声明没有方法体
2.抽象方法不能使用private进行修饰
3.interface关键字
使用interface修饰的java文件称之为接口
3.1接口
接口也可以称之为抽象到极致的抽象类
接口中可以包含什么?
1. 抽象方法 2.常量
public interface Godfather {
String name="123";
//接口中属性的默认修饰符是 public static final
void add();
//接口中方法的默认修饰符是 public abstract
}
为什么接口中的方法不能使用static final来进行修饰?
static:如果static进行修饰的话,那么就可以直接使用接口名调用,但是接口中的所有方法又是抽象,那么如果调用的话没有任何意义,所以不能使用static。
final:final修饰的方法叫最终方法,最终方法不可以被重写。 接口存在的意义就是被类实现从而重写所有的方法 ,final和接口理念冲突。
3.2 implements关键字
接口本身存在的意义不大。在程序中一般使用普通类使用implements来实现接口。
类使用接口
public class Son implements Godfather {
//当一个类实现接口时必须重写接口中的所有方法(接口中只有抽象方法)
@Override
public void name1() {
// TODO Auto-generated method stub
}
}
为什么要使用接口?
Java本身只支持单继承,为了弥补单继承的缺陷从而出现接口的概念。 因为接口支持多实现。实现多个接口的时候会逗号隔开
Java中支持一个类同时继承类和实现接口。但是规定了顺序。先基层再实现
public class Son extends Father implements Godfather,Godfaher2 {
@Override
public void earnMoney() {
// TODO Auto-generated method stub
}
@Override
public void cook() {
// TODO Auto-generated method stub
}
}
接口只能被实现吗?
接口可以被继承,但是只能被接口继承。同时接口可以多继承也可以多层继承。
public interface Godfaher2 {
void earnMoney();
}
public interface GodFather3 {
void spendMoney();
}
public interface Godfather extends Godfaher2,GodFather3{
void cook();
}
抽象类可以实现接口吗?是否需要重写抽象方法?
抽象类可以实现接口,而且可以不重写方法。
4.JDK1.8之后接口发生的改变
在Jdk1.8之后接口允许出现非抽象方法。还是不允许普通的方法出现。可以使用default方法和static是因为接口之前存在一些设计缺陷(当某一个接口被多次实现后,如果对接口进行拓展会变得非常麻烦。)
4.1 支持default方法
public interface UserService {
void findAllUser();
default void deleteByid() {
System.out.println("这是接口中的默认方法,便于接口的拓展");
}
}
//使用接口的默认方法
//1.需要一个普通类来实现接口
public class UserServiceImpl implements UserService {
@Override
public void findAllUser() {
// TODO Auto-generated method stub
}
}
//2.实例化这个普通类,通过对象直接调用
public class UserTest {
public static void main(String[] args) {
UserServiceImpl us = new UserServiceImpl();
us.deleteByid();
}
}
特性: 接口中的默认方法在使用的过程中,相当于普通类的继承
作用:便于对接口的拓展
4.2 支持static方法
static String findUserByid() {
return "这是接口中的静态方法";
}
如何调用接口的静态方法:通过接口名直接调用。
public class UserTest {
public static void main(String[] args) {
String s = UserService.findUserByid();
System.out.println(s);
}
}
5.工厂模式
//接口
public interface Car {
void drive();
}
//实现类1
public class Audi implements Car {
@Override
public void drive() {
// TODO Auto-generated method stub
System.out.println("这是奥迪驱动的方法");
}
}
//实现类2
public class Benz implements Car {
@Override
public void drive() {
// TODO Auto-generated method stub
System.out.println("这是奔驰驱动的方法");
}
}
//实现类3
public class Bmw implements Car{
@Override
public void drive() {
// TODO Auto-generated method stub
System.out.println("这是宝马驱动的方法");
}
}
//工厂类
public class Myfactory {
//创建汽车的方法
public static Car getCar(String cname) {
if(cname.equals("audi")) {
return new Audi();
}else if(cname.equals("bmw")) {
return new Bmw();
}else if(cname.equals("benz")) {
return new Benz();
}else {
return new Audi();
}
}
}
//测试类
public class Test {
public static void main(String[] args) {
Car car = Myfactory.getCar("benz");
car.drive();
}
}
6.策略模式
电影购票系统
原始开发模式:
//购票的类
public class MovieTicket {
private double price;
private String type;
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
//购票的方法
public double BuyingTickets() {
if(this.type.equals("student")) {
return this.price*0.9;
}else if(this.type.equals("children")) {
if(this.price>=30) {
return this.price-10;
}else {
return this.price*0.6;
}
}else if(this.type.equals("VIP")) {
return this.price*0.5;
}else {
return this.price;
}
}
}
//测试类
public class Test {
public static void main(String[] args) {
MovieTicket mt = new MovieTicket();
Scanner sc = new Scanner(System.in);
System.out.println("---------电影购票系统-----------");
System.out.println("1.学生票");
System.out.println("2.VIP票");
System.out.println("3.儿童票");
System.out.println("4.成人票");
System.out.println("请输入你属于那种客户");
int num = sc.nextInt();
mt.setPrice(100);
switch (num) {
case 1:
mt.setType("student");
double bt = mt.BuyingTickets();
System.out.println("本厂电影票原价为"+mt.getPrice()+",您的票价为"+bt);
break;
case 2:
mt.setType("VIP");
double bt2 = mt.BuyingTickets();
System.out.println("本厂电影票原价为"+mt.getPrice()+",您的票价为"+bt2);
break;
case 3:
mt.setType("children");
double bt3 = mt.BuyingTickets();
System.out.println("本厂电影票原价为"+mt.getPrice()+",您的票价为"+bt3);
break;
case 4:
mt.setType("");
double bt4 = mt.BuyingTickets();
System.out.println("本厂电影票原价为"+mt.getPrice()+",您的票价为"+bt4);
break;
default:
break;
}
}
}
策略模式:
//策略类的接口
public interface Discount {
double BuyingTickets(double price);
}
//学生票的实现类
public class StudentDiscount implements Discount {
@Override
public double BuyingTickets(double price) {
// TODO Auto-generated method stub
return price*0.9;
}
}
//儿童票的实现类
public class ChildrendDiscount implements Discount {
@Override
public double BuyingTickets(double price) {
// TODO Auto-generated method stub
return price*0.6;
}
}
//VIP票的实现类
public class VipDiscount implements Discount {
@Override
public double BuyingTickets(double price) {
// TODO Auto-generated method stub
return price*0.5;
}
}
//购票类
public class MovieTicket {
private double price;//原价
private Discount discount; // 接口 //策略类
public void setPrice(double price) {
this.price = price;
}
public void setDiscount(Discount discount) {
this.discount = discount;
}
//得到折扣后的票价
public double getPrice() {
return this.discount.BuyingTickets(this.price);
}
}
//测试类
public class Test {
public static void main(String[] args) {
MovieTicket mt = new MovieTicket();
mt.setPrice(100);
//ChildrendDiscount childrendDiscount = new ChildrendDiscount();
VipDiscount vipDiscount = new VipDiscount();
mt.setDiscount(vipDiscount);
double price = mt.getPrice();
System.out.println(price);
}
}