精华内容
下载资源
问答
  • Java接口

    千次阅读 多人点赞 2018-12-24 12:00:36
    Java接口也表示IS-A关系。它不能像抽象类一样被实例化。 q) Java为什么需要接口 通过接口实现多继承 用于实现耦合 如下图所示,一个类扩展了另一个类,一个接口扩展了另一个接口,一个类实现了一个接口。 接...


    java中的接口是类的蓝图。 它有静态常量和抽象方法。java中的接口是一种实现抽象的机制。 接口中只有抽象方法而不是方法体。接口用于在Java中实现抽象和多重继承。Java接口也表示IS-A关系。它不能像抽象类一样被实例化。

    q) Java为什么需要接口

    • 通过接口实现多继承
    • 用于实现耦合
      如下图所示,一个类扩展了另一个类,一个接口扩展了另一个接口,一个类实现了一个接口。
      在这里插入图片描述

    接口的用法

    interface Printer{                                                                //打印机的接口
    	void print();                                                        //打印机的打印方法
    }
    

    电脑来了

    class  Computer implements Printer{                                           //computer连接了Printer的方法
    	@override
    	public void print(){
    		System.out.println("我是电脑");                                        //把msg的方法打印出来
    	}
    }
    

    手机来了

    class SmartPhone implements Printer{                                   //手机连接了打印机
    	@override
    	public void print(){
    		System.out.println("我是智能手机");                           //手机的println()方法
    	}
    }
    

    Java 8接口特性

    Java 8以前的接口只能有抽象方法,不能有方法体
    Java 8开始可以有方法体,但是只能是默认的方法体和静态方法

    Q)为什么要加这两个特性呢?
    A)简单说,默认方法就是接口可以有实现方法,而且不需要实现类去实现其方法。我们只需在方法名前面加个default关键字即可实现默认方法。该策略可以解决多继承的问题。

    default方法可以解决兼容性问题和简单的解决多继承问题

    Java8之前
    HeadFirst Java 时,作者说,为了解决多重继承所引起的“致命方块问题”
    在这里插入图片描述
    所以Java不用多重继承,用多重实现,但是在多重实现中,这个问题解决了吗?还没有

    interface CanonPrinter{
    	void print();
    }
    
    interface DeliPrinter{
    	void ptint();
    }
    

    有一个类两个接口都支持,但是当答打印的时候

    class Computer implementsCannonPrinter,DeliPrinter{
    	@override
    	public void print(){
    		System.out.println("This is computer!!!");
    	}
    	public static void main(String[] args){
    		new Computer.print();
    	}
    }
    

    这个时候会出来个问题,你重写的打印的方法到底是实现了哪个接口的打印方法?
    如果CannonPrinter接口和DeliPrinter接口的print()方法相同,那么编译器认为你同时都实现了两个接口的两个方法,并且运行哪个方法都可以,因为两个接口的print()方法都一样。
    输出结果

    This is computer!!!
    

    如果同名方法只是参数类型不同呢?

    interface CanonPrinter{
    	void print(StringBuilder msg);
    }
    
    interface DeliPrinter{
    	void ptint(String msg);
    }
    
    class Computer implementsCannonPrinter,DeliPrinter{
    	@override
    	public void print(String msg){
    		System.out.println(msg);
    	}
    
    	@override
    	public void print(StringBuilder msg){
    		System.out.println(new StringBuilder(msg));
    	}
    	
    	public static void main(String[] args){
    		new Computer.print("This is Computer!!!");
    		new Computer.print(new StringBuilder("This is Computer!!!"))
    	}
    }
    

    编译器可以准确区分,没有产生歧义,所以输出结果

    This is Computer!!!
    This is Computer!!!
    

    如果print()方法返回参数不同呢?

    interface CanonPrinter{
    	String print();
    }
    interface DeliPrinter{
    	StringBuilder ptint();
    }
    
    class Computer implementsCannonPrinter,DeliPrinter{
    	@override
    	public String print(){                             //如果只实现了CanonPrinter 的返回类型为String的print(),
    		return "This is computer!!!";               //没有实现DeliPrinter的StringBuilder的print()方法,编译器会报错	                                                                         
    	}                                                  //所以只实现一个接口的方法,是违背接口的规则的,不能通过编译。
    
    	@override
    	public int  print(){                                     //如果实现了两个方法,编译器则会报错,因为名字重复
    		return new StringBuilder("This is computer!!!");  //当对象调用的时候,不知道调用的是哪个方法                                                                         
    	}                                                        
    
    	
    	public static void main(String[] args){
    		new Computer.print();                                      //我调用的是哪个方法呢?
    	}
    }
    

    如果两个不同的接口各有同名且不同返回类型的方法,如果一个类想同时实现这两个接口,无解,在编译时就会报错,没有办法实现。除非把问题变得复杂,使用内部类。

    interface CanonPrinter{
    	String print();
    }
    interface DeliPrinter{
    	StringBuilder ptint();
    }
    
    class Computer implements CannonPrinter{
    	@override
    	public String print(){                             
    		return "This is computer!!!";               
    	}                                                  
    
    	@override
    	public int  print(){
    		return new StringBuilder("This is computer!!!");  
    	}                                                        
    	class MultiComputer implements DeliPrinter{
    		@override
    		public String print(){                            
    			return "This is computer!!!"; 
    		}                                                  
    
    		@override
    		public int  print(){
    			return new StringBuilder("This is computer!!!");  
    		}
    	}
    }
    

    但是Java8新特性后

    public class Java8Tester {
       public static void main(String args[]){
          Vehicle vehicle = new Car();
          vehicle.print();
       }
    }
     
    interface Vehicle {
       default void print(){
          System.out.println("我是一辆车!");
       }
        
       static void blowHorn(){
          System.out.println("按喇叭!!!");
       }
    }
     
    interface FourWheeler {
       default void print(){
          System.out.println("我是一辆四轮车!");
       }
    }
     
    class Car implements Vehicle, FourWheeler {
       public void print(){
          Vehicle.super.print();
          FourWheeler.super.print();
          Vehicle.blowHorn();
          System.out.println("我是一辆汽车!");
       }
    }
    

    输出结果

    我是一辆车!
    我是一辆四轮车!
    按喇叭!!!
    我是一辆汽车!
    

    这样你就可以区分使用哪个接口的方法。
    同时default方法还可以解决兼容性。
    当你在接口中添加一个方法时,需要所有实现它的类都实现它的抽象方法。就会带来不必要的操作,但如果使用默认方法,你只需在接口中添加好方法体,之后在需要实现的类中调用就可以了,减少了不必要的操作。
    例如:

    interface Printer{
    	void print{};
    }
    

    实现类

    class computer implements Printer{
    	@override
    	public void print(){
    		System.out.print("This is Computer");
    	}
    }
    class SmartPhone implements Printer{
    	@override
    	public void print(){
    		System.out.print("This is smartPhone");
    	}
    }
    

    如果需要给接口添加一个方法

    interface Printer{
    	void print{};
    	default void println(){
    		System.out.println("增加了Println()方法")
    	};                                                                                   //新添加的方法
    }
    

    实体类需要实现

    class Computer implements Printer{
    	@override
    	public void print(){
    		System.out.print("This is Computer");
    	}
    	@override
    	default void prinln(){
    		System.out.println("This is println() for Computer");             //这里用,就在这里重写好了,其他实现了Printer的类就不用管了
    	}
    	
    }
    class SmartPhone implements Printer{
    	@override
    	public void print(){
    		System.out.print("This is smartPhone");
    	}
    }
    

    接口中的静态方法可以用做保存常用方法

    我们知道常量可以用接口来保存
    例如

    interface addressCodeConstant{
    	String CHINA = "CN";
    	String AMERICA = "US";
    }
    

    同理常用方法,也就是常用工具方法可以用static来修饰
    例如

    interface getAddressCode{
    	static String returnAdressCod(String country){
    		switch (country){
    			case CHINA :
    				return CN;
    			case AMERICA:
    				return US;
    			default:
    				retrun null;
    		} 	
    	}
    }
    

    相当于

    public final getAddressCode{
    	public String returnAdressCod(String country){
        		switch (country){
        			case CHINA :
        				return CN;
        			case AMERICA:
        				return US;
        			default:
        				retrun null;
        		} 	
        	}
    }
    

    只不过以后的常用方法可以存储像常量一样存储在接口中了。

    标记接口

    没有成员的接口(仅定义一个空的接口)称为标记或标记接口。 例如:可序列化,可克隆,远程等。它们用于向JVM提供一些基本信息,以便JVM可以执行一些有用的操作。

    //How Serializable interface is written?  
    public interface Serializable{  
    
    }
    
    展开全文
  • java什么是接口

    千次阅读 2019-07-14 16:35:00
    接口就是一个规范,类似于硬件上面的接口,在电脑主板上的PCI插槽的规范就类似于Java接口,只要是遵循PCI接口的卡,不过是什么牌子的都可以插入到PCI插槽中。所以接口就是一个规范。接口就是某个事物对外提供的一些...

    一、什么是接口

    接口就是一个规范,类似于硬件上面的接口,在电脑主板上的PCI插槽的规范就类似于Java接口,只要是遵循PCI接口的卡,不过是什么牌子的都可以插入到PCI插槽中。所以接口就是一个规范。接口就是某个事物对外提供的一些功能的说明。我们还可以利用接口实现多态功能,同时接口也弥补了Java单一继承的弱点,也就是类可以实现多个接口。

    我们使用interface关键字定义接口,一般使用接口声明方法或常量,接口中的方法只能是声明,不能是具体的实现,这一点和抽象类是不一样的。接口是更高级别的抽象。接口的定义格式是

    public interface 接口名称{

    //可以定义常量

    //方法只有方法声明,而且是公共的。

    public void 方法名称();

    ...

    }

    类要实现接口,只需要使用implements关键字,实现类必须要实现接口中的所有的方法

    public class 实现类名 implements 接口{

    //实现接口的方法

    }

    二、接口的应用

    定义一个接口非常简单,当然其实要设计一个好的接口并不是很简单,你必须要想好这个接口有什么常量和方法。但是技术却非常简单,示例代码如下:

    // 定义方法的接口
    public interface Myinterface {
      // 定义程序使用的常量的接口,接口中只能有常量。
      public static final double price = 1450.00;
      public static final int counter = 5;
      //接口中所有的方法都没有方法体。
      public void add(int x, int y);
      public void volume(int x,int y, int z);
    }

     

    实现接口也没有什么难度,代码如下:

                               //实现     接口
    public class MyImple implements Myinterface {
        @Override
            public void add(int x, int y) {
        }
        @Override
            public void volume(int x, int y, int z) {
        }
    }

     

    一个类是可以实现多个接口,因为java是单继承的,这点接口可以弥补。我们可以再定义一个接口

    public interface MyInterface2 {
         public void countpp();
    }

     

    修改上面的实现类,要实现多个接口,可以使用逗号隔开,当然所有的接口的方法都要实现。

                               //实现       接口1,接口2
    public class MyImple implements Myinterface ,MyInterface2{
        @Override
        public void add(int x, int y) {
        }
        @Override
        public void volume(int x, int y, int z) {
        }
        @Override
        public void countpp() {
        }
    }

     

    三、接口和抽象类有什么区别

    abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。其实,两者之间还是有很大的区别的

    1、抽象类里面可以有非抽象方法。但接口里只能有抽象方法,接口体现的是一种规范,抽象类体现的是模板式设计。

    2、接口(interface)是抽像类的变体。在接口中,所有方法都是抽像的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽像的,没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似,除了该实现类不能从接口定义中继承行为。当类实现特殊接口时,它定义(即将程序体给予)所有这种接口的方法。然后,它可以在实现了该接口的类的任何对像上调用接口的方法。由于有抽像类,它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换,instanceof 运算符可以用来决定某对象的类是否实现了接口

    3、接口里不可以定义静态方法,抽象类里可以。接口里的变量全部为静态常量,抽象类里可以有普通变量。

    4.接口里不可以有构造函数和初始化块,抽象类里可以有。

    5.一个类可以实现多个接口,但只能继承一个抽象类。

     

    转载于:https://www.cnblogs.com/weibanggang/p/11184674.html

    展开全文
  • Java中类名、接口名、变量名、方法名命名规则

    万次阅读 多人点赞 2018-11-26 11:09:02
    (Java中类名、接口名、变量名、方法名居然可以是中文的) 今天不经意发现Java中类名、接口名、变量名、方法名可以是中文的,然后上去编码了一下。 public class 中文 { public static void main(String[] args) {...

    今天不经意发现Java中类名、接口名、变量名、方法名可以是中文的,然后上去编码了一下。

    public class 中文 {
    	public static void main(String[] args) {
      		int 数量=10;
      		System.out.println(数量);
      }
      }
    

    发现编译器并没有报错,是不是觉得开发这软件的是不是很好玩呢?

    虽然是有点好玩,但是在一般情况下这些都是用英文比较好,一来是为了更快地编码,二来为了防止后期的编码错误,毕竟开发软件都是别人发明的,很难保证编码不会出错。

    1. 变量名命名的规则需要注意的点
    • 只能由字母、数字、“_”和“$”符组成;
    • 不能以数字开头,一般全小写;如int number;
    • Java大小写敏感,命名变量时需要注意;
    • 不能使用Java关键字(一些Java语言规定好的,定义好的字符),像int、if、for、break等,当你确实不知道哪些是关键字,你写了编译器会报错的,那时你修改了就行了。
    • 可以以中文作为变量名(不提倡)。
    1. 类名的命名规则
    • 首字母大写,通常由多个单词合成一个类名,要求每个单词的首字母也要大写,例如class MyFirstApp;
    1. 接口名
    • 命名规则与类名相同,例如interface MyFirstApp;
    1. 方法名
    • 往往由多个单词合成,第一个单词通常为动词,首字母小写,中间的每个单词的首字母都要大写,例如:makeApp;
    1. 常量名
    • 一般全都是大写,如果有多个单词,那么使用下划线链接即可。
    public static final int MAX_VALUE=10;
    String final DRIVER="com.jdbc.mysql.Driver";//一般有final,常量不能被更改,
    

    对于final类型的变量,对于不加static我们可以有两种方式给它赋值:声明变量时直接赋值;在构造方法中完成赋值,如果一个类有多个构造方法,就要保证在每个构造方法中都要完成对该final类型变量的初始化工作。对于一个变量既是final又是static的,我们必须在声明变量时直接赋值。
    初次创建博客,2018年11月26号,纪念一下。如有写得不好的地方,希望谅解,欢迎提供建议和评论。

    既然选择了远方 便只顾风雨兼程。

    展开全文
  • java web开发(二) 接口开发

    万次阅读 多人点赞 2016-06-03 16:50:34
    java web开发(一) 环境搭建讲解了如何搭建一个Java Web项目,如果你还没了解,建议先浏览下!今天这篇文章主要讲解的就是接口开发,打算使用比较古老的或者说比较原始方法实现的接口。 一.数据库设计。 假设要做...

        java web开发(一) 环境搭建讲解了如何搭建一个Java Web项目,如果你还没了解,建议先浏览下!今天这篇文章主要讲解的就是接口开发,打算使用比较古老的或者说比较原始方法实现的接口。

    一.数据库设计。

        假设要做一个简单的学生信息管理系统,数据库名为students_manage,并且先设计一张学生表,表名为student。

    1.打开Sqlyog工具,如果还没创建连接,可以点击新建,输入名称,点击确定即可,

    2.然后在保存的连接中选择,刚刚新建的连接,只需要在密码输入框中输入,安装数据库时的设置的密码,点击连接,其他的默认即可,

    如果都ok的话,那么将会出现如下界面,就代表连接成功了!

    3.连接成功后,首先创建数据库,在左边的空白区域,鼠标右键,创建数据库,输入数据库名称students_manage,其他的默认,

    点击创建即可,然后在左边的数据库列表中会多一个students_manage的数据库,

    4.创建数据库成功后,我们便可以创建数据库表,选中students_manage的数据库中的Tables文件夹,右边,创建表,输入表的字段,类型,设置主键,是否可为空等,

    点击创建表按钮,便会看到在Tables文件夹中,多一个student表,

    5.双击student表,便会打开该表。我们需要给该表中,先初始化一些数据,点击表数据,然后插入数据,点击保存。

    此时表中已有2条记录。

    数据库的简单设计就差不多了,接下来,我们需要开发接口!

    PS: 实际开发中,数据库设计肯定不是这样的,需要先根据需求分析,做出原型,画出模型图(类图、活动图等),然后使用专门的数据库建模工具,完成数据库与表的设计!

    二.接口项目开发。(如果对这一部分有疑问或者不清楚的,欢迎查看java web开发(四) 接口开发补坑1 java web开发(五) 接口开发补坑2!)

        接口返回的数据格式是JSON,如果你对JSON还不熟悉,可以先看看文章 JSON 使用讲解JSON 解析

       1.新建项目。这个就不多说了!这一块要是还不了解,请看这篇文章, java web开发(一) 环境搭建

       2.设计接口的Json数据格式。

        2.1.接口返回的Json数据格式如下:

       (1).返回对象,

    {"code":" ","msg":" ","time":1464937933230,"object":{}}

       (2).返回数组,

    {"code":" ","msg":" ","time":1464937933230,"items":[{},{}]}

    好多读者都留言,有“code”这个属性不解。  这儿说明下,  Json格式数据中的“code”属性是响应状态码,是标志接口数据的状态!例如当接口数据返回成功,会设置code为‘ok’。当我们拿到这个“code”时,会根据不同的值,做不同的处理。当“code”等于“ok”时,我们就可以正常解析这个json数据了;返回其他值,我们就只需要作出提示即可。而具体code值是什么,要根据接口自己定义一个规范,当调用者拿到这个code时,就知道如何处理了。有关这个“code”,更加详细的内容,请看 java web开发(五) 接口开发补坑2

    目前就设计返回以上两种格式。如果你有分页的话,也可以加上。下面,就展示一下具体实现。

        (1).建立AbstractJsonObject(Json数据的基类),具体实现如下:

    public class AbstractJsonObject {
            //code
    	private String code;
    	//msg
    	private String msg;
    
    	private Long time = new Date().getTime();
    
    	public String getCode() {
    		return code;
    	}
    
    	public void setCode(String code) {
    		this.code = code;
    	}
    
    	/**
    	 * @return the time
    	 */
    	public Long getTime() {
    		return time;
    	}
    
    	/**
    	 * @param time
    	 *            the time to set
    	 */
    	public void setTime(Long time) {
    		this.time = time;
    	}
    
    	public String getMsg() {
    		return msg;
    	}
    
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}
    
    	public void setContent(String code, String msg) {
    		this.code = code;
    		this.msg = msg;
    	}
    
    	public void setStatusObject(StatusObject statusObject) {
    		this.code = statusObject.getCode();
    		this.msg = statusObject.getMsg();
    	}
    }
    

        其中,StatusObject是一个状态对象,封装了状态码(code)和状态信息(msg),具体实现如下:

    /**
     * 状态对象
     */
    public class StatusObject {
    	// 状态码
    	private String code;
    
    	// 状态信息
    	private String msg;
    
    	public StatusObject(String code, String msg) {
    		super();
    		this.code = code;
    		this.msg = msg;
    	}
    
    	public String getCode() {
    		return code;
    	}
    
    	public void setCode(String code) {
    		this.code = code;
    	}
    
    	public String getMsg() {
    		return msg;
    	}
    
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}
    
    }
    

        (2).建立Json对象类SingleObject,代码:

    public class SingleObject extends AbstractJsonObject {
    
    	private Object object;
    
    	public Object getObject() {
    		return object;
    	}
    
    	public void setObject(Object object) {
    		this.object = object;
    	}
    
    }

        (3).建立Json数组类ListObject,代码:

    public class ListObject extends AbstractJsonObject {
    
    	// 列表对象
    	private List<?> items;
    
    	public List<?> getItems() {
    		return items;
    	}
    
    	public void setItems(List<?> items) {
    		this.items = items;
    	}
    
    }

    经过上面几步,我们所需要的json格式数据就创建好了,接下来就是生成json数据了,这儿使用jackjson,JackJson 库下载。下载完jackson库后,将三个包导入到项目的lib目中,截图所示:

       (4).JackJsonUtils生成json数据和解析json数据,代码:

    public class JackJsonUtils {
    	static ObjectMapper objectMapper;
    	/**
    	 * 解析json
    	 * 
    	 * @param content
    	 * @param valueType
    	 * @return
    	 */
    	public static <T> T fromJson(String content, Class<T> valueType) {
    		if (objectMapper == null) {
    			objectMapper = new ObjectMapper();
    		}
    		try {
    			return objectMapper.readValue(content, valueType);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * 生成json
    	 * 
    	 * @param object
    	 * @return
    	 */
    	public static String toJson(Object object) {
    		if (objectMapper == null) {
    			objectMapper = new ObjectMapper();
    		}
    		try {
    			return objectMapper.writeValueAsString(object);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    }

        至此,json数据设计就ok了!是不是没有想象的那么难?也许,就真的这么简单!接下来,就是接口的开发了。

        3.接口开发。

          本篇文章开发接口使用的是古老的servlet实现的,关于servlet,请自行查找资料,这里就不多说了(其实我也就一知半解)

          3.1.创建一个类继承自HttpServlet,例如StudentInq,鼠标右键,新建->选择Servlet,截图所示输入Servlet名称,点击Finish按钮,就ok了!

    此时你会发现包下多了一个StudentInq类,具体代码:

    public class StudentInq extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    
    	/**
    	 * @see HttpServlet#HttpServlet()
    	 */
    	public StudentsInq() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	/**
    	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse
    	 *      response)
    	 */
    	protected void doGet(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		
    	}
    
    	/**
    	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse
    	 *      response)
    	 */
    	protected void doPost(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    		// TODO Auto-generated method stub
    
    		doGet(request, response);
    	}
    
    }

        实现HttpServlet的doGet()和doPost方法,此处为了简单就只实现doGet()。

    PS: 如果你比较细心的话,会发现在web.xml文件中多了几行代码,具体如下截图:(web.xml 是网络程序中的一个很重要的配置文件,更具体的、详细的请查询相关文档)

    可以看到我们刚才新建servlet,在这个xml文件中显示了。后面我们在调用接口的时候便会用到这个配置清单。

        3.2. 接口实现。

        我们就简单的实现一个学生查询接口!调用查询接口,返回数据库中所有的学生信息。

       (1).新建一个接口StudentService,代码:

    public interface StudentService {
    	public List<Students> getAllStudents();
    }

        (2). 实现该接口,StudentServiceImpl代码:

    public class StudentServiceImpl implements StudentService{
    
    	@Override
    	public List<Students> getAllStudents() {
    		// TODO Auto-generated method stub
    		return StudentBusiness.getAllStudents();
    	}
    
    }

       其中,StudentBusiness提供了从数据库获取学生信息的方法。有关数据库操作下面会讲到。接着,我们实现Servlet的doGet(),具体代码:

     List<Students> list = new StudentServiceImpl().getAllStudents();
    		ListObject listObject=new ListObject();
    		listObject.setItems(list);
    		listObject.setStatusObject(StatusHouse.COMMON_STATUS_OK);
    		String responseText = JackJsonUtils.toJson(listObject);
    		ResponseUtils.renderJson(response, responseText);

       其中,ResponseUtils是将返回的json数据写入到response中。

       至此,生成json数据已经成功了!但是 貌似少了什么操作?这些数据是从哪里来的?原来数据库还没有连接呢!!!好吧!请继续看下文。

       4. 数据库连接。

        文章开头,我们已经创建好了数据库以及表,并且也添加了几条测试数据。数据有了,我们需要在项目中获取到,那么该怎么操作呢?

       (1). 数据库连接。

        我们连接mysql数据库,需要导入mysql-connector.jar,jar包下载链接下载好jar后,导入到lib目录中,

       (2). 建立DBHelper连接数据库以及关闭连接:

    public class DBHelper {
    	
    	 public static final String url = "jdbc:mysql://localhost:3306/students_manage";  
    	    public static final String name = "com.mysql.jdbc.Driver";  
    	    public static final String user = "****";  
    	    public static final String password = "******";  
    	  
    	    public Connection conn = null;  
    	    public PreparedStatement pst = null;  
    	  
    	    public DBHelper(String sql) {  
    	        try {  
    	            Class.forName(name);//
    	            conn = DriverManager.getConnection(url, user, password);//
    	            pst = conn.prepareStatement(sql);//
    	        } catch (Exception e) {  
    	            e.printStackTrace();  
    	        }  
    	    }  
    	  
    	    public void close() {  
    	        try {  
    	            this.conn.close();  
    	            this.pst.close();  
    	        } catch (SQLException e) {  
    	            e.printStackTrace();  
    	        }  
    	    }  
    
    }

    代码很简单了,不需要多说!

        这一步,我们是连接数据库,连接成功后,就可以使用表中的数据了!

    PS: 实际开发中,有关数据库操作,肯定不是这么简单的!比较常用的是框架来管理数据库相关操作,例如SpringMvc、hibernate和mybats等框架。

    三. 运行。

        经过上面几步,我们就大致完成了一个简单使用Servlet的接口开发,接下来就是见证奇迹的时刻了!

    PS: 在运行前,可以在WebContent中添加一个index.jsp,index.jsp代码:

    <%@ page language="java" contentType="text/html; charset=ISO-8859-1"
        pageEncoding="ISO-8859-1"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    <title>Insert title here</title>
    </head>
    <body>
    	<h1>hello world!</h1>
    	<h2>This is my test page!</h2>
    	<h3>Welcome to my page!</h3>
    </body>
    </html>

     (1).在项目上,右键->Run As->Run to Server。

    如果一切都正常的话,(如果你创建了index.jsp,你会看到一个jsp页面;如果没有创建index.jsp,可能会显示一个404界面,当然没有创建index.jsp不会影响咱们接口的调试)

       (2).我们在浏览器中输入‘http://localhost:8080/mServer/StudentInq’,如果一切都正常的话,会显示:

       或者在浏览器中输入本机的ip地址,例如’http://192.168.1.133:8080/mServer/StudentInq‘,

    看到这个界面,顿时泪流满面!!

    四. 总结。

        这么长的篇幅终于实现了简单接口的开发,不容易啊!太感动了!我们总结一下本篇博客实现开发接口的步骤:

    (1). 数据库表设计;

    (2). json数据设计;

    (3). 接口实现。

      总结后,是不是感觉很简单呢!从此以后,只要看到接口数据不如意的,你都可以随便来改!!(实际上接口开发要牵扯好多东西,如果你要了解或者熟悉更多有关接口开发,那么就需要结合Web框架,例如SSH,Springmvc等等,本篇文章只是很基础的入门开发)至此,通过这篇文章,相信你对接口不再生疏了!下篇文章将介绍,后台接口服务和前端客户端结合,详情请看,java web开发(三) 接口使用

      最后补上,例子下载地址。由于csdn下载需要积分,所以,我在github上也放置了源码,下载地址是,接口开发服务端源码地址

     PS: json格式化工具

    推荐文章:SpringMVC 开发接口

    博文中经常有小伙伴留言,有关接口项目的问题,最近就推出几篇补坑的文章,打算这几篇文章详解项目中的代码以及业务流程,java web开发(四) 补坑1 java web开发(五) 接口开发补坑2!欢迎大家查看!

    最近才开通了微信公众号,欢迎大家关注。

    展开全文
  • java接口的意义

    万次阅读 多人点赞 2019-05-23 16:51:55
    接口的最主要的作用是达到统一访问,就是在创建对象的时候用接口创建,【接口名】 【对象名】=new 【实现接口的类】,这样你像用哪个类的对象就可以new哪个对象了,不需要改原来的代码,就和你的US...
  • java接口测试

    千次阅读 2017-11-14 10:30:55
    第一次做接口测试,网上找了很久,找不到想要的,只能自己摸索写了测试代码T.T ApiRequestUtil.javapackage com.util.api;import java.io.BufferedReader; import java.io.IOException; import java.io....
  • java中的接口什么

    千次阅读 多人点赞 2018-06-30 14:36:20
    接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。接口并不是类,编写接口的方式和类很相似,但是...
  • Java接口详解

    千次阅读 多人点赞 2016-08-03 12:40:22
    Java 8对接口进行了改进,允许在接口中定义默认方法,默认方法可以提供方法实现。一、接口的概念 我们经常在生活中听到接口这个词,比如PCI接口、AGP接口,因此很多人认为接口相当于主板上一个插槽,这其实是一种...
  • java接口实现

    千次阅读 2018-04-19 15:55:53
    1 接口只是抽象的,之描述所应该具备的方法,并没有具体实现,将功能的定义与实现分离,接口里全是抽象的方法,编译后仍会产生.class文件2 接口的定义public interface 接口名{抽象方法一;抽象方法二;抽象方法...
  • 先看看什么是标记接口?标记接口有时也叫标签接口(Tag interface),即接口不包含任何方法。在Java里很容易找到标记接口的例子,比如JDK里的Serializable接口就是一个标记接口。 首先明确一点,Marker Interface...
  • java 实现接口

    千次阅读 2018-06-30 10:11:19
    6.2 实现接口 1 类实现接口 在Java语言中,接口由类来实现... 如果实现多个接口,用逗号隔开接口名,例如A类实现Pintable和Addable接口。classA implements Printable,Addable 再如,Animal 的Dog子类实现Eatable...
  • 读者春夏秋冬在抽象类的那篇文章中留言,“二哥,面试官最喜欢问的一个问题就是,‘兄弟,说说抽象类和接口之间的区别?’,啥时候讲讲接口呗!” 对于面向对象编程来说,抽象是...当然了,在没有搞清楚接口到底是什么
  • Java接口

    千次阅读 多人点赞 2019-06-25 14:10:47
    接口表示的是功能的集合,可看做是一种数据类型,接口中全是抽象方法,没有普通方法,是比抽象更抽象的“类”,接口只描述应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口...
  • 浅谈Java接口中为什么只能定义常量

    千次阅读 2017-09-05 10:18:58
    接口的含义:接口就是提供一种统一的’协议’,而接口中的属性也属于’协议’中的成员.它们是公共的,静态的,最终的常量.相当于全局常量。 抽象类是不’完全’的类,相当于是接口和具体类的一个中间层.即满足接口的抽象...
  • 《Java核心技术卷I》java接口 笔记

    千次阅读 多人点赞 2021-03-03 21:42:27
    接口用来描述类应该做什么,而不指定他们应该怎么做。 接口不是类,而是对希望符合这个接口的类的一组需求。不可以实例化(new)一个接口 一个类可以实现零或多个接口 接口的所有方法都是public抽象方法,所以可以省略...
  • Java接口声明对象

    千次阅读 2015-10-11 16:40:28
    Java接口本身没有任何实现,因为Java接口不涉及表象,而只描述public行为,所以Java接口比Java抽象类更抽象化。但是接口不是类,不能使用new ...用JAVA接口声明一个变量是什么意思? 不是接口变量,而是一个接口类型的
  • java接口

    万次阅读 2017-04-29 09:02:04
    1、一个类最多只能有一个直接的父类。但是有多个间接的父类。...接口的定义格式: interface 接口名 { }接口要注意的事项: 1、接口是一个特殊的类。 2、接口的成员变量默认的修饰符为: public static fi
  • java 接口可以多继承

    万次阅读 多人点赞 2015-06-16 10:08:28
    接口是常量值和方法定义的集合。...java接口可以多继承。Interface3 Extends Interface0, Interface1, interface…… 以下是spring ApplicationContext 接口的代码,同时继承了多个接口 public interface Appli...
  • Java 接口interface的详解

    千次阅读 2016-07-16 21:50:17
    interface 接口名{ 属性 抽象方法 } 接口的体验 interface Inter { int num = 6; 可以定义属性与方法。 void show(); }注意:  接口中的所有属性 默认的修饰符是 public static final。
  • Java接口和Java抽象类

    千次阅读 热门讨论 2008-05-29 14:57:00
    Java接口和Java抽象类 在没有好好地研习面向对象设计的设计模式之前,我对Java接口和Java抽象类的认识还是很模糊,很不可理解。 刚学Java语言时,就很难理解为什么要有接口这个概念,虽说是可以实现所谓的多继承,...
  • Java接口和应用程序接口API的理解

    千次阅读 2019-05-19 18:16:21
    Java接口和应用程序接口API的理解 Java中接口中的方法是抽象方法,API(应用程序接口),他们都是接口。问题是一般的Java接口中的方法是抽象方法,而API中的方法却是可以直接调用的。 1.具体的编程语言中的接口,...
  • Java8函数接口

    千次阅读 2020-09-20 01:21:16
    什么是函数接口:函数接口就是只定义一个抽象方法的接口,但同时可以拥有默认方法,为了简化函数方法的实现可以使用lambda表达式,其基本语法如下: (parameters) -> expression # 控制流语句需要使用{} Java...
  • java抽象类和接口什么意义

    千次阅读 2021-02-04 16:53:06
    什么是抽象类(abstract class) 使用abstract修饰符修饰的类。官方点的定义就是:如果一个类没有包含足够多的信息来描述一个具体的对象,这样的类就是抽象类。 实际点来说,一个抽象类不能实例化,因为“没有包含...
  • JAVA - 类名、接口名、文件名

    千次阅读 2018-06-12 06:02:39
    * 一个JAVA文件中至多有一个public类或接口(内部类除外,内部类作为外部类的内部成员,可以存在多个内部类是用public修饰的)* 如果文件中有public类,文件名必须与public类名或接口名一致* 如果文件中没有public类...
  • Java接口的概念

    万次阅读 2018-04-20 00:37:44
    接口的概念 在Java接口是一个全部由抽象方法组成的集合,接口需要用interface定义,里面只能有抽象的方法和常量。接口体现的是事物扩展的功能,在Java中,类定义了一个实体,包括实体的属性,实体的行为。而接口...
  • Java接口与实现

    千次阅读 2018-06-24 22:16:19
    转自:https://blog.csdn.net/qq_33518744/article/details/52673782接口声明:interface 接口名字接口体:接口体中包含常量的声明(没有变量)和抽象方法两部分。常量是public, static,final型常量,方法是public...
  • Java中类名,接口名与文件名

    千次阅读 2012-10-19 23:03:12
    1.Java保存的文件名必须与public类或接口名一致; 2.一个Java文件中只能有一个public类或接口;; 3.如果文件中public类或接口,文件名可任意。  一个 .java 文件,可以有多个类,但是文件名只能有一个,用哪一...
  • Java 中的接口什么作用?

    万次阅读 多人点赞 2018-03-10 11:06:29
    Java 中的接口什么作用? 例如我定义了一个接口,但是我在继承这个接口的类中还要写接口的实现方法,那我不如直接就在这个类中写实现方法岂不是更便捷,还省去了定义接口接口java中的作用是什么?个人觉得...
  • Python调用java接口

    千次阅读 2017-03-10 18:58:02
    用python requests模块的get方法请求拿到java提供的接口中的东西(接口是返回A类信息)  re=requests.get(re_url)  process_res=json.loads((re.text)) 若得到的是类的信息的话(在python中,获得的东西放到...
  • classB Extends classAjava接口可以多继承。Interface3 Extends Interface0, Interface1, interface……不允许类多重继承的主要原因是,如果A同时继承B和C,而B和C同时有一个D方法,A如何决定该继承那一个呢?但接口...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 893,201
精华内容 357,280
关键字:

java接口名是什么

java 订阅