精华内容
下载资源
问答
  • 常用的类和接口
    万次阅读 多人点赞
    2019-05-30 18:15:44

    一、抽象类

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

    1.抽象方法:使用abstract修饰且没有方法体的方法。

    特点:

    ① 抽象方法没有方法体,交给子类实现

    ② 抽象方法修饰符不能是private final static

    ③ 抽象方法必须定义在抽象类或者接口中

    2.抽象类:包含抽象方法的类,即使用abstract修饰的类。

    特点:

    ① 抽象类不能被实例化,只能被继承

    ② 抽象类中可以不包含抽象方法(不包含抽象方法就没有太大意义,可以作为工具类防止被实例化)

    ③ 抽象类的子类可以不实现该类所有的抽象方法,但也必须作为抽象类(抽象派生类)

    ④ 抽象类的构造方法不能定义成私有(子类构造方法会调用父类构造方法)

    ⑤ 抽象类不能使用final修饰,final修饰的类不能被继承

    实例:武器作为一个抽象类具备攻击行为(attack方法),具体如何攻击(how2Attack方法)需要子类实现。如:机关枪可以射击敌人,手榴弹可以丢向敌人。

    public class Test3 {
        public static void main(String[] args) {
            Gun gun = new Gun("机关枪");
            Grenade grenade = new Grenade("手榴弹");
            gun.attack();
            grenade.attack();
            gun.how2Attack();
            grenade.how2Attack();
        }
    }
    
    abstract class Weapon{
        String name;
        public void attack(){
            System.out.println(name+"具有攻击行为");
        }
    
        abstract void how2Attack();
    
    }
    class Gun extends Weapon{
        public Gun(String name) {
            this.name = name;
        }
    
        @Override
        void how2Attack() {
            System.out.println(name+"射击敌人");
        }
    }
    class Grenade extends Weapon{
        public Grenade(String name){
            this.name = name;
        }
        @Override
        void how2Attack() {
            System.out.println(name+"丢向敌人");
        }
    }

    二、接口

    1.什么是接口

    ① 硬件接口:是指同一计算机不同功能层之间的通信规则称为接口。

    ② 软件接口:是指对协定进行定义的引用类型。其他类型实现接口,以保证它们支持某些操作。

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

    特点:

    ① 接口中没有构造器,不能被实例化

    ② 接口只能继承接口,不能继承类,接口支持多继承

    ③ 接口中的定义的成员变量,默认是public static final修饰的静态常量

    ④ 接口中定义的方法,默认是public abstract修饰的抽象方法

    ⑤ 接口中定义的内部类,默认是public static修饰的静态内部类

    标志接口:仅仅作为一个定义,就是一个标志

    常量接口:用来封装多个常量信息

    注意在JDK8中,接口也可以定义静态方法和默认非静态方法,可以直接用接口名调用静态方法,实现类可以调用默认非静态方法。如果同时实现两个接口,接口中定义了一样的默认方法,则实现类必须重写默认方法,不然会报错

    实例:走路和游泳作为两个抽象的行为,青蛙可以实现两个行为接口来具体实现行为的内容

    public class Test4 {
        public static void main(String[] args) {
            Frog frog = new Frog("青蛙");
            frog.getName();
            frog.work();
            frog.swim();
        }
    }
    class Animal {
        String name;
    
        public String getName() {
            System.out.println("Animal:"+name);
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    interface IWalk{
        void work();
    }
    interface ISwim{
        void swim();
    }
    class Frog extends Animal implements IWalk,ISwim{
    
        public Frog(String name) {
            this.name = name;
        }
    
        @Override
        public void work() {
            System.out.println(this.name+":蹦蹦跳跳地走路");
        }
    
        @Override
        public void swim() {
            System.out.println(this.name+":在水里蛙泳");
        }
    }

    三、抽象类和接口的异同点

    1.语法层面

    相同点:

    ① 抽象类和接口都不能被实例化

    ② 抽象类和接口都可以定义抽象方法,子类/实现类必须覆写这些抽象方法

    不同点:

    ① 抽象类有构造方法,接口没有构造方法

    ② 抽象类可以包含普通方法,接口中只能是public abstract修饰抽象方法(Java8之后可以)

    ③ 抽象类只能单继承,接口可以多继承

    ④ 抽象类可以定义各种类型的成员变量,接口中只能是public static final修饰的静态常量

    2.设计层面

    抽象类是对一种事物的抽象,即对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。举个简单的例子,飞机和鸟是不同类的事物,但是它们都有一个共性,就是都会飞。那么在设计的时候,可以将飞机设计为一个类Airplane,将鸟设计为一个类Bird,但是不能将 飞行 这个特性也设计为类,因此它只是一个行为特性,并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly,包含方法fly( ),然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机,比如战斗机、民用飞机等直接继承Airplane即可,对于鸟也是类似的,不同种类的鸟直接继承Bird类即可。从这里可以看出,继承是一个 "是不是"的关系,而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类,则子类必定是抽象类的种类,而接口实现则是有没有、具备不具备的关系,比如鸟是否能飞(或者是否具备飞行这个特点),能飞行则可以实现这个接口,不能飞行就不实现这个接口。

    设计层面不同,抽象类作为很多子类的父类,它是一种模板式设计。而接口是一种行为规范,它是一种辐射式设计。什么是模板式设计?最简单例子,大家都用过ppt里面的模板,如果用模板A设计了ppt B和ppt C,ppt B和ppt C公共的部分就是模板A了,如果它们的公共部分需要改动,则只需要改动模板A就可以了,不需要重新对ppt B和ppt C进行改动。而辐射式设计,比如某个电梯都装了某种报警器,一旦要更新报警器,就必须全部更新。也就是说对于抽象类,如果需要添加新的方法,可以直接在抽象类中添加具体的实现,子类可以不进行变更;而对于接口则不行,如果接口进行了变更,则所有实现这个接口的类都必须进行相应的改动。

     

    四、抽象类和接口的使用场景

    1.抽象类的使用场景

    既想约束子类具有共同的行为(但不再乎其如何实现),又想拥有缺省的方法,又能拥有实例变量

    如:模板方法设计模式,模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中某些步骤的具体实现。

    2.接口的应用场景

    ① 约束多个实现类具有统一的行为,但是不在乎每个实现类如何具体实现

    ② 作为能够实现特定功能的标识存在,也可以是什么接口方法都没有的纯粹标识。

    ③ 实现类需要具备很多不同的功能,但各个功能之间可能没有任何联系。

    ④ 使用接口的引用调用具体实现类中实现的方法(多态)

    个人见解,若有错误请指出,谢谢!

     

    参考资料:https://www.cnblogs.com/dolphin0520/p/3811437.html

    更多相关内容
  • java常用类和接口初步学习

    千次阅读 2021-08-02 16:50:55
    常用类 一.Object 含义: 所有类的基类/超类,一个类没有明确继承的类,默认继承Object 1.equals 比较两个对象内存地址是否相同 源码实现: public boolean equals(Object obj){ return this == obj; } 代码...

    常用类

    一.Object

    含义:

    所有类的基类/超类,一个类没有明确继承的类,默认继承Object

    1.equals

    比较两个对象内存地址是否相同

    源码实现:

    public boolean equals(Object obj){
        return this == obj;
    }
    

    代码实现:

    public static void main(String[] args) {
        
        Object obj1 = new Object();//0x001
        Object obj2 = new Object();//0x002
    
        boolean equals = obj1.equals(obj2);
        System.out.println(equals);//false
    
        boolean bool = obj1 == obj2;
        System.out.println(bool);//false
    
    }
    

    2.getClass

    获取该类的字节码文件对象

    代码实现:

    public static void main(String[] args) {
        
        Object obj1 = new Object();//0x001
        Object obj2 = new Object();//0x002
    
        Class<? extends Object> c1 = obj1.getClass();
        Class<? extends Object> c2 = obj2.getClass();
    
        System.out.println(c1 == c2);//true
    
    }
    
    //应用于反射,实现获得类的字节码文件对象后获取类中的属性和方法.
    public static void main(String[] args) {
    		
        A a = new A();
    
        //获取A类的字节码文件对象
        Class<? extends A> c = a.getClass();
    
        //获取A类中所有属性
        Field[] declaredFields = c.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
        }
    
        //获取A类中所有的方法
        Method[] declaredMethods = c.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method);
        }
    
    }
    

    3.hashCode

    获取对象的hash值
    hash值=系统利用对象的内存地址+散列算法获取的一个值
    注意:hash值不等于内存地址

    代码实现:

    public static void main(String[] args) {
    
        Object obj1 = new Object();
        Object obj2 = new Object();
    
        System.out.println(obj1.hashCode());
        System.out.println(obj2.hashCode());
    }
    

    4.toString

    获取对象的字符串表示(将对象转换为字符串)

    源码实现:

    public String toString(){
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    

    代码实现:

    public static void main(String[] args) {
    
        Object obj1 = new Object();
    
        //java.lang.Object@15db9742
        System.out.println(obj1.toString());
        
    }
    

    二.Object标杆作用

    1.equals

    判断两个对象是否相同,Object不同的子类判断两个的对象是否相同有不同的判断规则,子类重写equals即可

    代码实现:

    public static void main(String[] args) {
    
        User user1 = new User("1445584980", "123123");
        User user2 = new User("1445584980", "123123");
    
        System.out.println(user1.equals(user2));//重写toStrong方法后输出true
    
        System.out.println(user1);//默认调用toString
    
    }
    package com.dream.test02;
    
    public class User {
    	
    	private String username;
    	private String password;
    
    	public User() {
    	}
    
    	public User(String username, String password) {
    		this.username = username;
    		this.password = password;
    	}
    
    	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;
    	}
    	
    	@Override
    	public boolean equals(Object obj) {
    		if(this == obj){
    			return true;
    		}
    		
    		User user = (User) obj;
    		if(this.username.equals(user.username)){
    			return true;
    		}
    		return false;
    	}
    	
    	@Override
    	public String toString() {
    		return username + " -- " + password;
    	}
    }
    

    2.toString

    返回对象的字符串表示,Object不同的子类有不同的属性,重写toString,返回属性

    需求:

    public static void main(String[] args) {
         //需求:
         //两个学生班级号+学号一样视作同一学生
         //打印学生对象:把该学生所有的属性都打印出来
        Student stu1 = new Student("春日野结衣", '女', 18, "2107", "001");
        Student stu2 = new Student("卢永刚", '男', 21, "2107", "001");
    
        System.out.println(stu1.equals(stu2));//true
    
        System.out.println(stu1);//春日野结衣--女--18--2107--001
    }
    
    public class Student {
    	
    	private String name;
    	private char sex;
    	private int age;
    	private String classId;
    	private String id;
    	
    	public Student() {
    	}
    
    	public Student(String name, char sex, int age, String classId, String id) {
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    		this.classId = classId;
    		this.id = id;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public char getSex() {
    		return sex;
    	}
    
    	public void setSex(char sex) {
    		this.sex = sex;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	public String getClassId() {
    		return classId;
    	}
    
    	public void setClassId(String classId) {
    		this.classId = classId;
    	}
    
    	public String getId() {
    		return id;
    	}
    
    	public void setId(String id) {
    		this.id = id;
    	}
    	
    	@Override
    	public boolean equals(Object obj) {
    		if(this == obj){
    			return true;
    		}
    		
    		Student stu = (Student) obj;
    		if(this.classId.equals(stu.classId) && this.id.equals(stu.id)){
    			return true;
    		}
    		return false;
    	}
    
    	@Override
    	public String toString() {
    		return "name=" + name + ", sex=" + sex + ", age=" + age + ", classId=" + classId + ", id=" + id;
    	}
    }
    

    三.String底层源码

    String的equals为什么可以判断字符串内容?
    底层把String的内容转换为字符数组,依次比较ASCII码

    代码实现:

    package com.dream.test02;
    
    public class Test03 {
    
    	public static void main(String[] args) {
    		
    		String str1 = new String("abc");
    		String str2 = new String("abc");
    		System.out.println(str1 == str2);//false
    		System.out.println(str1.equals(str2));//true - 比较两个字符串内容是否相同
    		System.out.println(str1);//默认调用toString
    		System.out.println(str2);//默认调用toString
    		
    		System.out.println("--------------");
    		
    		MyString m1 = new MyString("abc");
    		MyString m2 = new MyString("abc");
    		System.out.println(m1 == m2);//false
    		System.out.println(m1.equals(m2));
    		System.out.println(m1);
    		System.out.println(m2);
    		
    	}
    }
    package com.dream.test02;
    
    public class MyString {
    	
    	private String value;
    
    	public MyString(String value) {
    		this.value = value;
    	}
    	
    	@Override
    	public boolean equals(Object obj) {
    		if(this == obj){
    			return true;
    		}
    		
    		MyString m = (MyString) obj;
    		
    		//['a','b','c']
    		char[] v1 = this.value.toCharArray();//把当前对象的str转换为字符数组
    		//['a','b','c']
    		char[] v2 = m.value.toCharArray();//把当前对象的str转换为字符数组
    		
    		if(v1.length != v2.length){
    			return false;
    		}
    		
    		for (int i = 0; i < v2.length; i++) {
    			if(v1[i] != v2[i]){
    				return false;
    			}
    		}
    		
    		return true;
    	}
    
    	@Override
    	public String toString() {
    		return value;
    	}
    }
    

    四.switch使用字符串细节

    两个字符串hash值有可能相同(利用反编译便于理解)

    代码实现:

    package com.dream.test02;
    
    public class Test04 {
    
    	public static void main(String[] args) {
    
    		String str = "ab";
    
    		switch (str) {//switch (str.hashCode()) {
    		case "ab"://case 3104:
    			if(str.equals("ab")){
    				System.out.println("ab");
    			}
    			break;
    		case "aa"://case 3105:
    			if(str.equals("aa")){
    				System.out.println("aa");
    			}
    			break;
    		case "bC"://case 3105:
    			if(str.equals("bC")){
    				System.out.println("bb");
    			}
    			break;
    		}
    
    	}
    }
    

    五.final的使用

    作用:

    作用:
    1.修饰变量 - 常量
    存储在常量池中,直到项目结束才会被销毁
    2.修饰类,类不能被继承
    3.修饰方法,方法不能被重写

    代码实现:

    package com.dream.test03;
    
    //A类不能有子类
    //public final class A {
    public class A {
    
    	//该方法不能被子类重写
    	public final void method(){}
    }
    package com.dream.test03;
    
    public class B extends A{
    	//当父类A被final修饰,B不能继承A
        //父类中被final修饰的方法不能在子类中重写
    }
    

    六.抽象类

    抽象方法:

    抽象方法:没有代码块并使用abstract修饰的方法,交给非抽象的子类去重写
    应用场景:当一个方法必须在父类中出现,但是这个方法又不好实现,就把该方法变成抽象方法,或交给非抽象的子类去实现

    需求:

    //需求:编写人类、中国人、日本人
    package com.study.test02;
    
    public abstract class Person {
    	private String name;
    	private int age;
    	private char sex;
    	public Person() {
    		super();
    	}
    	public Person(String name, int age, char sex) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    	}
    	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;
    	}
    	
    	@Override
    	public String toString() {
    		return "Person [name=" + name + ", age=" + age + ", sex=" + sex + "]";
    	}
    	
    	public abstract void eat();
    }
    
    package com.study.test02;
    
    public class Japanese extends Person{
    
    	private String yearNums;
    
    	public Japanese() {
    		
    	}
    	
    	public String getYearNums() {
    		return yearNums;
    	}
    
    
    	public void setYearNums(String yearNums) {
    		this.yearNums = yearNums;
    	}
    
    	public Japanese(String name, int age, char sex, String yearNums) {
    		super(name, age, sex);
    		this.yearNums = yearNums;
    	}
    
    
    	@Override
    	public String toString() {
    		return "Japanese [yearNums=" + yearNums + ", toString()=" + super.toString() + "]";
    	}
    
    	@Override
    	public void eat() {
    		System.out.println(super.getName() + "吃生鱼片");
    	}
    	
    }
    
    package com.study.test02;
    
    public abstract class Chinese extends Person{
    
    	private String ID;
    	
    	public Chinese() {
    		
    	}
    	
    	public Chinese(String name, int age, char sex, String iD) {
    		super(name, age, sex);
    		ID = iD;
    	}
    
    	public String getID() {
    		return ID;
    	}
    
    	public void setID(String iD) {
    		ID = iD;
    	}
    
    	@Override
    	public String toString() {
    		return "Chinese [ID=" + ID + ", toString()=" + super.toString() + "]";
    	}
    	
    	public abstract void hobby();
    }
    
    package com.study.test02;
    
    public class SiChuan extends Chinese{
    
    	public SiChuan() {
    		super();
    	}
    
    	public SiChuan(String name, int age, char sex, String iD) {
    		super(name, age, sex, iD);
    	}
    
    	@Override
    	public void hobby() {
    		System.out.println(super.getName() + "打麻将");
    		
    	}
    
    	@Override
    	public void eat() {
    		System.out.println(super.getName() + "吃火锅");
    	}
    
    	@Override
    	public String toString() {
    		return "SiChuan [toString()=" + super.toString() + "]";
    	}
    
    }
    
    package com.study.test02;
    
    public class GuangDong extends Chinese{
    
    	
    	public GuangDong() {
    		super();
    	}
    
    	public GuangDong(String name, int age, char sex, String iD) {
    		super(name, age, sex, iD);
    	}
    
    	@Override
    	public void hobby() {
    		System.out.println(super.getName() + "做生意");
    		
    	}
    
    	@Override
    	public void eat() {
    		System.out.println(super.getName() + "吃潮汕火锅");
    	}
    
    	@Override
    	public String toString() {
    		return "GuangDong [toString()=" + super.toString() + "]";
    	}
    
    }
    
    package com.study.test02;
    
    public class Test01 {
    	public static void main(String[] args) {
    		
    		Japanese j = new Japanese("小峰由衣", 28 , '女', "令和");
    		j.eat();
    		System.out.println(j);
    		
    		SiChuan sc = new SiChuan("林成", 18 , '男', "123456789");
    		sc.eat();
    		System.out.println(sc);
    		
    		GuangDong gd = new GuangDong("李嘉诚", 80 , '男', "987654321");
    		gd.eat();
    		System.out.println(gd);
    	}
    }
    
    /*输出结果:
    小峰由衣吃生鱼片
    Japanese [yearNums=令和, toString()=Person [name=小峰由衣, age=28, sex=女]]
    林成吃火锅
    SiChuan [toString()=Chinese [ID=123456789, toString()=Person [name=林成, age=18, sex=男]]]
    李嘉诚吃潮汕火锅
    GuangDong [toString()=Chinese [ID=987654321, toString()=Person [name=李嘉诚, age=80, sex=男]]]
    */
    

    深入抽象类:

    1.抽象类中只能有抽象方法?

    抽象类里可以有构造方法、静态方法、成员方法

    2.抽象类中不可以没有抽象方法?

    可以没有抽象方法,但是这样毫无意义

    3.如果父类是抽象类,则子类必须实现父类的抽象方法?

    子类如果是抽象类,可以不实现父类对的抽象方法

    4.抽象类不能有构造方法?

    可以有构造方法的

    5.可以使用new关键字来创建抽象类对象?

    不可以的,创建出的是匿名内部类的对象

    代码实现:

    public static void main(String[] args) {
    
        //1.创建匿名类,继承Chinese,重写eat、hobby方法
        //2.创建匿名类的对象
        //3.赋值给父类的引用
        Chinese c = new Chinese() {
            @Override
            public void eat() {
            }
            @Override
            public void hobby() {
            }
        };
    }
    

    七.接口

    含义:

    1.接口是特殊的抽象类

    2.接口中只能有静态常量和抽象方法

    3.JDK1.8的新特性允许接口中使用默认方法和静态方法

    作用:

    制定规范

    代码实现:

    package com.dream.test06;
    
    public class Test01 {
    	
    	public static void main(String[] args) {
    		
    		A a = new A();
    		a.defaultMethod();
    		
    		I1.staticMethod();
    		
    	}
    }
    package com.dream.test06;
    
    public interface I1 {
    
    	//默认添加public static final
    	int i = 100;
    	
    	//默认添加abstract
    	public void method01();
    	public void method02();
    	
    	//默认方法
    	default void defaultMethod(){
    		System.out.println("接口中的默认方法");
    	}
    	
    	//静态方法
    	public static void staticMethod(){
    		System.out.println("接口中的静态方法");
    	}
    	
    }
    package com.dream.test06;
    
    public class A implements I1{
    
    	@Override
    	public void method01() {
    	}
    
    	@Override
    	public void method02() {
    	}
    
    }
    

    八.深入接口

    类——接口的关系:

    类 - 类:单继承

    类 - 接口:多实现

    接口 - 接口:多继承

    面试题:

    1.一个类可以实现多个接口?可以
    2.一个接口可以实现多个接口?不可以,接口与接口之间是多继承关系
    3.接口里面的方法不一定都是抽象的?JDK1.8开始接口中允许默认方法和静态方法
    4.接口解决了类的单继承问题?是的
    5.一个类是否可以继承一个类并同时实现多个接口?可以
    6.接口可以new对象?不可以,创建的是匿名内部类的对象

    代码实现:

    package com.dream.test07;
    
    public interface I1 {
    	
    	public void i1Method01();
    
    	public void method01();
    	
    	default void method02(){}
    }
    package com.dream.test07;
    
    public interface I2 {
    	
    	public void i2Method01();
    	
    	public void method01();
    	
    	default void method02(){}
    
    }
    package com.dream.test07;
    
    public interface I3 extends I4,I5{
    	
    	public void i3Method01();
    
    }
    package com.dream.test07;
    
    public interface I4 {
    	
    	public void i4Method01();
    
    }
    package com.dream.test07;
    
    public interface I5 {
    	
    	public void i5Method01();
    
    }
    package com.dream.test07;
    
    public class A extends Object implements I1,I2,I3{
    
    	@Override
    	public void i2Method01() {
    	}
    
    	@Override
    	public void i1Method01() {
    	}
    
    	@Override
    	public void i4Method01() {
    	}
    
    	@Override
    	public void i5Method01() {
    	}
    
    	@Override
    	public void i3Method01() {
    	}
    
    	//I1、I2中都有method01的抽象方法,在实现类中只实现一个
    	@Override
    	public void method01() {
    	}
    
    	@Override
    	public void method02() {
    		//在实现类中调用I1接口中的默认方法
    		//I1.super.method02();
    		I2.super.method02();
    	}
    
    }
    public class Test01 {
    	
    	public static void main(String[] args) {
            
    		//1.创建匿名类,实现I5接口中的i5method01方法
    		//2.创建匿名类的对象
    		//3.赋值给接口的引用
    		I5 i5 = new I5() {
    			@Override
    			public void i5Method01() {
    			}
    		};
    	}
    }
    
    展开全文
  • JDBC中常用类和接口

    千次阅读 2020-03-30 20:21:33
    Connection接口代表与特定的数据库的连接,在连接上下文中执行SQL语句并返回结果,该常用方法如下: Connection接口常用方法 方法 功能描述 createStatement() 创建Statement对象 createStatement...

    一、Connection接口

    Connection接口代表与特定的数据库的连接,在连接上下文中执行SQL语句并返回结果,该类的常用方法如下:

    Connection接口的常用方法
    方法功能描述
    createStatement()创建Statement对象
    createStatement(int resultSetType,int resultSetConcurrency)创建一个Statement对象,该对象将生成具有给定类型、并发性和可保存性的ResultSet对象
    preparedStatement()创建预处理对象preparedStatement
    isReadOnly()查看当前Connection对象的读取模式是否是只读形式
    setReadOnly()设置当前Connection对象的读写模式,默认是非只读模式
    commit()

    使所有上一次提交/回滚后进行的更改成为持久更改,并释放此Connection对象当前持有的所有数据库锁

     

    roolback()取消在当前事务中进行的所有更改,并释放此Connection对象当前持有的所有数据库锁
    close()立即释放此Connection对象的数据库和JDBC资源,而不是等待它们被自动释放

     

    二、Statement接口

    Statement接口用于在已经建立的基础上向数据库发送SQL语句。在JDBC中有3种Statement对象,分别是Statement、PreparedStatement和CallableStatement。Statement对象用于执行不戴参数的简单SQL语句;PreparedStatement继承了Statement,用来执行对数据库的存储过程的调用。Statement接口的常用方法如下:

    Statement接口种常用的方法
    方法功能描述
    execute(String sql)执行静态的SELECT语句,该语句可能返回多个结果集
    executeQuery(String sql)执行给定的SQL语句,该语句返回单个ResultSet对象
    clearBatch()清空此Statement对象的当前SQL命令列表
    executeBatch()将一批命令提交给数据库来执行,如果全部命令执行成功,则返回更新计数组成的数组。数组元素的排序与SQL语句的添加顺序对应
    addBatch()将给定的SQL命令添加到此Statement对象的当前命令列表中。如果驱动程序不支持批量处理,将抛出异常
    close()释放Statement实例占用的数据库和JDBC资源

     

    三、PreparedStatement接口

    PreparedStatement接口用来动态地执行SQL语句。通过PreparedStatement实例执行的动态SQL语句,将被预编译并保存到PreparedStatement实例中,从而可以反复地执行该SQL语句,该接口的常用方法如下:

    PreparedStatement接口提供的常用方法
    方法功能描述
    setInt(int index,int k)将指定位置的参数设置为int值
    setFloat(int index,float k)将指定位置的参数设置为float值
    setLong(int index,long k)将指定位置的参数设置为long值
    setDouble(int index,double k)将指定位置的参数设置为double值
    setBoolean(int index,boolean k)将指定位置的参数设置为boolean值
    setDate(int index,date date)将指定位置的参数设置为对应的date值
    executeQuery()在此PreparedStatement对象中执行SQL查询,并返回该查询生成的ResultSet对象
    setString(int index,String s)将指定位置的参数设置为对应的String值
    setNull(int index,intsqlType)将指定位置的参数设置为SQL NULL
    executeUpdate()执行前面包含的参数的动态INSERT、UPDATE或DELETE语句
    clearParameters()清除当前所有参数的值

     

    四、DriverManager类

    DriverManager类用来管理数据库中的所有驱动程序。它是JDBC的管理层,作用于用户和驱动程序之间,跟踪可用的驱动程序,并在数据库的驱动程序之间建立连接。如果通过getConnection()方法可以建立连接,则经连接返回,否则抛出SQLException异常,该类的常用方法如下:

    DriverManager类的常用方法
    方法功能描述
    getConnection(String url,String user,String passward)指定三个入口参数(数据库的URL、用户名、密码)来获取与数据库的连接
    setLoginTimeout()获取驱动程序试图登录到某一数据库时可以等待的最长时间,单位为秒
    println(String message)将一条消息打印到当前的JDBC日志流中

     

     

     

     

     

     

    五、ResultSet接口

    ResultSet接口类似于一个临时表,用来暂时存放数据库查询操作所获得的结果集。ResultSet实例具有指向当前数据行的指针,指针开始的位置在第一条记录的前面,通过next()方法可以将指针向下移动。该接口的常用方法如下:
     

    ResultSet接口提供的常用方法
    方法功能描述
    getInt()以int形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL,则返回值是0
    getFloat()以float形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL,则返回值是0
    getDate()以data形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL,则返回值是null
    getBoolean()以boolean形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL,则返回值是null
    getString()以String形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL,则返回值是null
    getObject()以Object形式获取此ResultSet对象的当前行的指定列值。如果列值是NULL,则返回值是null
    first()将指针移到当前记录的第一行
    last()将指针移到当前记录的最后一行
    next()将指针向下移一行
    beforeFirst()将指针移到集合的开头
    afterLast()将指针移到集合的尾部
    absolute(int index)将指针移到ResultSet给定编号的行
    isFrist()判断指针是否位于当前ResultSet集合的第一行。如果是返回true,否则返回false
    isLast()判断指针是否位于当前ResultSet集合的最后一行。如果是返回true,否则返回false
    updateInt()用int值更新指定列
    updateFloat()用float值更新指定列
    updateLong()用指定的long值更新指定列
    updateString()用指定的string值更新指定列
    updateObject()用Object值更新指定列
    updateNull()将指定的列值修改为NULL
    updateDate()用指定的date值更新指定列
    updateDouble()用指定的double值更新指定列
    getrow()查看当前行的索引号
    insertRow()将插入行的内容插入到数据库
    updateRow()将当前行的内容同步到数据表
    deleteRow()删除当前行,但不同步到数据库中,而是在执行close()方法后同步到数据库

     

    展开全文
  • Java中的抽象类和接口

    千次阅读 多人点赞 2022-04-08 15:17:42
    各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象类和接口到底是什么? 里面也会讲到多态呀,一起来看看吧

    目录

    什么是抽象类

    抽象类再实现多态中的意义 

    接口是什么


     各位铁汁们大家好呀😊

    😎今天让我们继续学习java,看看java中的抽象类和接口到底是什么🤔? 

    什么是抽象类

    🍑我们之前学过什么是类,那么抽象类是不是也是类的一种呢?

    听名字就感觉好抽象呀!说对了,他就是抽象的,不是具体的。在类中没有包含足够的信息来描绘一个具体的对象,这样的类称为抽象类。

    🌰来看一个抽象类的例子

    // 抽象类和抽象方法需要被 abstract 关键字修饰
    abstract class Shape {
        // 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体
        abstract void draw();
    }

    大家觉得这个抽象类是不是什么也没干,他唯一的方法draw()还是空的。

    像这样的类是不是就没有包含足够的信息来描绘一个具体的对象,自然也就不能实例化对象了。不信你看:

    🍑那既然一个类不能实例化,那这种抽象类存在的意义是什么呀🤔?别急,存在即合理,听我慢慢道来。


    抽象类在实现多态中的意义 

    🍑抽象类存在的一个最大意义就是被继承,当被继承后就可以利用抽象类实现多态。

    来看一段代码

    // 抽象类和抽象方法需要被 abstract 关键字修饰
    abstract class Shape {
        // 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体
        abstract void draw();
    }
    // 当一个普通类继承一个抽象类后,这个普通类必须重写抽象类中的方法
    class Cycle extends Shape {
        @Override
        void draw() {  // 重写抽象类中的draw方法
            System.out.println("画一个圆圈");
        }
    }
    
    public class Test4 {
        public static void main(String[] args) {
            //Shape shape = new Shape();  抽象类虽然不能直接实例化
            // 但可以把一个普通类对象传给一个抽象类的引用呀,即父类引用指向子类对象
            Shape shape = new Cycle(); // 这称作:向上转型
            
            /*Cycle cycle = new Cycle();
              Shape shape = cycle // 这是向上转型的另一种写法
             */
            shape.draw();         // 通过父类引用调用被子类重写的方法
        }
    }
    

    运行之后你就会发现神奇的一幕:

     

    大家在看完了代码可能会有很多疑问,别急咱们一个一个的说,

    📝什么是向上转型:一句话总结就是“父类引用指向子类对象”

    向上转型后的变化

    1. 🏀关于方法:父类引用可以调用子类和父类公用的方法(如果子类重写了父类的方法,则调用子类的方法),但子类特有的方法无法调用。
    2. 🏀关于属性: 父类引用可以调用父类的属性,不可以调用子类的属性

    向上转型的作用

    1. 🐟减少一些重复性的代码
    2. 🐟对象实例化的时候可以根据不同需求实例化不同的对象

    🌰这样的话就我们上面的代码就可以理解了

    ​ 

    📝看来,我们可以通过子类对抽象类的继承和重写,抽象类还真有点用呀!

    🍑但这和多态有什么关系呢,抽象类用起来这么麻烦,我还不如直接用普通类,也能达到这样的效果,还不用再写一个子类呢😫?

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

    🌰那行,你再看看下面的代码,你就知道抽象类在实现多态时的好处了。 

    abstract class Shape {
        public abstract void draw(); // 抽象方法不能里有具体的语句
    }
    // 当一个普通类继承一个抽象类的时候,再这个子类中必须重写抽象类中的抽象方法
    class Cycle extends Shape {  
        @Override              // 如果不重写会报错,但如果继承的是普通类则不会报错,用抽象类更安全
        public void draw() {
            System.out.println("画一个圆圈");
        }
    }
    class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
        @Override
        public void draw() {
            System.out.println("画一朵花");
        }
    }
    class Square extends Shape {
        @Override
        public void draw() {
            System.out.println("画一个正方形");
        }
    }
    
    public class Test4 {
        public static void main(String[] args) {
            Cycle cycle = new Cycle();   // 子类引用cycle
            Flower flower = new Flower(); // 子类引用flower
            Square square = new Square();
            
            // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
            // 在这个过程其实也发生了向上转型,对抽象类中的方法进行了重写
            Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
            for (int i = 0; i < shapes.length; i++) {
                Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象
    
                shape.draw();  // 通过父类引用调用子类重写的draw方法
            }
    
        }
    }
    

    🍑调用同一个方法竟然打印出了不同的结果😮,这难道就是所谓的多态🤔 

     是不是有点懵😂,下面我们来解释一下😉

    // 对上面的代码补充一下
    // 可能你对 Shape[] shapes = {cycle, flower, square};不太理解
    // 但上面的代码就相当于 
    
     Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀!数组大小为3
    
    // (将指向->子类对象)的子类引用赋值给父类对象,不就相当于该夫类引用指向->所对应的子类对象吗
    //这是向上转型的另一种写法,应为前面已经实例化了子类对象  Cycle cycle = new Cycle();   
     shapes1[0] = cycle;  // 如果前面没实例化子类对象,就要写成shape1[0] = new Cycle
     shapes1[1] = flower;
     shapes1[2] = square;

    对于多态来说,他有这三个要素

    1. 继承(我们刚才的Cycle类继承Shape抽象类)
    2. 重写(我们子类对draw方法的重写)
    3. 父类指向子类对象(就是shape1[0] = cycle -->也可以称作向上转型) 

    🍑回头再看一下我们的代码,是不是就刚好符合了多态的三要素😉。

    📝当我们的父类引用指向不同的子类对象时,当我们调用同一个draw方法时却输出了不同的结果。(其实就是该方法再子类中被重写成了不同形式)这就叫做多态 。

    嘻嘻😂,其实只要只要结合着例子来看,多态也没那么难理解呀😎

      

    🍑那为啥一定要用抽象类呢😂?我一个普通类继承普通类来实现多态不可以吗🤔

    🌰当然可以,但不太安全有风险;

         

    但如果是抽象类的话,就不一样了😉 

      

    🍑从这我们也可以看出,当用抽象类的时候,编译器自动就对我们是否重写进行了校验,而充分利用编译器的校验, 在实际开发中是非常有意义的 。所以说抽象类还是有用的,嘻嘻😉

    📝好了,相信到这里你对抽象类也有了一个大概的认识😊,下面我们来简单做一下总结

    1. 使用abstract修饰的类或方法,就抽象类或者抽象方法
    2. 抽象类是不能具体的描述一个对象,不能用抽象类直接实例化对象
    3. 抽象类里面的成员变量和成员方法,都是和普通类一样的,只不过就是不能进行实例化了
    4. 当一个普通类继承这个抽象类后,那么这个普通类必须重写抽象类当中的所有的抽象方法🤔(我们之前说过抽象类是不具体的,没有包含足够的信息来描述一个对象,所以我们需要把他补充完整)
    5. 但当一个抽象类A继承了抽象类B,这是抽象类A就可以不重写抽象类B当中的抽象方法
    6. final不能修饰抽象类和抽象方法(因为抽象类存在的最大意义就是被继承,而被final修饰的不能被继承,final和抽象,他们两个是天敌😂)
    7. 抽象方法不能被private修饰(抽象方法一般都是要被重写的,你被private修饰了,还怎么重写😫)
    8. 抽象类当中不一定有抽象方法,但如果一个类中有抽象方法,那么这个类一定是抽象类

    🌰哈哈,上面的8条总结是不是臭长臭长的,大家也不用专门去记(用的多了,自然就记住了😉)

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟


    接口是什么

    🍑抽象类是从多个类中抽象出来的模板,如果将这种抽象进行的更彻底,则可以提炼出一种更加特殊的“抽象类”——接口(Interface)🤔。

    📝接口是Java中最重要的概念之一,它可以被理解为一种特殊的类,不同的是接口的成员没有执行体,是由全局常量和公共的抽象方法所组成😎。

    如何定义一个接口呢?下面我们来看一个栗子🌰

    //接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口
    
    public interface 接口名称{
    // 定义变量
    int a = 10;      // 接口当中的成员变量默认都是public static final
    
    // 抽象方法
    public abstract void method1(); // public abstract 是固定搭配,可以不写
    void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
    }

    可以看到接口和类其实还是有很多相似点:

    📝接口中也包含抽象方法,所以也不能直接实例化接口🤔,那么我们怎么用接口呢?

    🍑哈哈,很简单😉,我们再用一个普通类实现这个接口不就行了吗😂,不同的是抽象类是被子类来继承而实现的,而接口与类之间则是用关键字implements来实现

    📝就像普通类实现实现抽象类一样,一个类实现某个接口则必须实现该接口中的抽象方法,否则该类必须被定义为抽象类🤔。


     通过接口实现多态

    🍑铁汁们!刚才我们是用抽象类来实现多态,那么现在我们可以尝试用接口来实现多态,嘻嘻😎

    接口可以看成是一种特殊的类,只能用 interface 关键字修饰
    interface IShape {
        int a = 10;   接口当中的成员变量默认都是public static final
        int b = 23;
        void draw();  接口当中的成员方法一般只能是抽象方法,默认是public abstract(JDK1.8以前)
      
        default void show() {
            System.out.println("接口中的其他方法");//接口中的其他方法也可以实现,但要用default修饰
        }
        public static void test() {
            System.out.println("这是接口当中的一个静态的方法");
        }
    }
    
    // 一个普通的类要想实现接口,可以用implement, 
    //因为接口也是抽象方法的,所以实现接口的这个类也要重写抽象方法
    class Cycle implements IShape {
    
        @Override
        public void draw() {
            System.out.println("画一个圆圈");
        }
    }
    class Square implements IShape {
        @Override
        public void draw() {
            System.out.println("画一个正方形");
        }
    }
    class Flower implements IShape {
    
        @Override
        public void draw() {
            System.out.println("画一朵花");
        }
    }
    public class Test4 {
        public static void main(String[] args) {
            // IShape iShape = new IShape(); 接口也不能直接实例化
            Cycle cycle = new Cycle();
            Square square = new Square();
            Flower flower = new Flower();
            // 这里的IShape接口就相当与抽象类中父类,接口类型也是一种引用类型
    
            IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型
    
            for (IShape iShape : iShapes) { // 增强型的for—each循环,也可以写成普通的for循环形式
                iShape.draw();              // 通过重写实现了多态
            }
        }
    }
    引用变量cycle和square都赋值给了Shape类型的引用变量shape,
    但当执行shape.draw()时,java虚拟机到底要调用谁重写的的draw方法,
    就看此时接口引用的是那个对象的,是shape的、还是cycle的

     😎看一下运行结果😎

     看完代码你可能有点晕😫,但没关系。一般接口咱也不这么用,直接使用抽象类不就好了😉(我只是演示一下用接口也能实现多态😂)

    🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑

    📝下面我们来总结一下Java中接口的几个主要特点

    1. 🌰接口中可以包含变量和方法,变量被隐式指定为 public static final,方法被隐式指定为 public abstract(JDK 1.8 d一个类可以同时实现多个接口,一个类实现某个接口则必须实现该接口中的抽象方法,否则该类必须被定义为抽象类
    2. 🌰接口支持多继承,即一个接口可以继承(extends)多个接口,间接解决了 Java 中类不能多继承的问题。

    🍑那么接口一般用在什么地方呢?

    • 一般情况下,实现类和它的抽象类之前具有 "is-a" 的关系,但是如果我们想达到同样的目的,但是又不存在这种关系时,使用接口。
    • 由于 Java 中单继承的特性,导致一个类只能继承一个类,但是可以实现一个或多个接口,此时可以使用接口。

    🌰下面就让我们来看看接口的正确用法:帮助java实现“ 多继承 ”😎

    由于 Java 中单继承的特性,导致一个类只能继承一个类,但是可以实现一个或多个接口,此时可以使用接口。
    class Animal {
        String name;        // 不能使用private,后面的子类也要用
    
        public Animal(String name) { // 父类的自定义的构造方法
            this.name = name;
        }
    }
    interface IFlying {   // 自定义多种接口
        void fly();
    }
    interface IRunning {
        void run();
    }
    interface ISwimming {
        void swimming();
    }
    // 小鸭子,不仅会跑,还会游泳、飞行
    一个类继承父类,并实现多个接口,间接的解决java中不能多继承的问题
    class Duck extends Animal implements IRunning, ISwimming, IFlying {
    
        public Duck(String name) {  // 子类构造方法
            super(name);            // 必须在子类构造方法的第一行
            // 在给实现子类的构造方法前,先要用super()调用实现父类的构造方法,比较先有父后有子呀!
            // 因为父类自己定义了构造方法,编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法,需要我们自己实现
        }
        // 对接口中的抽象方法进行重写
        @Override
        public void fly() {
            System.out.println(this.name + "正在用翅膀飞");
        }
    
        @Override
        public void run() {
            System.out.println(this.name + "正在用两条腿跑");
        }
    
        @Override
        public void swimming() {
            System.out.println(this.name + "正在漂在水上");
        }
    
    }
    
    public class 接口的使用 {  // 不用学我用中文名作为类名,我只是为演示方便
        public static void main(String[] args) {
            Duck duck = new Duck("第一个小鸭子");  // 实例化鸭子对象
            duck.fly();  // 通过引用 变量名.方法名 输出重写后的方法
            duck.run();
            duck.swimming();
        }
    }
    有人可能会说干嘛用接口,我直接在父类Animal中实现fly、run、swimming这些属性,
    然后不同的动物子类再继承父类这些方法不行吗?
    
    但问题是,鸭子会fly、swimming,那猫会飞和游泳吗?你再写个其他动物的子类是不是就不行了
    而用接口呢?我们只是把这种飞、游泳的行为给抽象出来了,
    
    只要一个子类有这种行为,他就可以实现相对应的接口,接口是更加灵活的
    
    

     📝上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。

     📝继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 ,能实现接口的类和该接口并不一定有is_a的关系,只要该类有这个接口的特性就行

    猫是一种动物, 具有会跑的特性.

    青蛙也是一种动物, 既能跑, 也能游泳

    鸭子也是一种动物, 既能跑, 也能游, 还能飞

     🍑这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,只要这个类有有这个特性就好。

    举个栗子🌰

    class Robot implements IRunning {
        private String name;
        public Robot(String name) {
            this.name = name;
        }
        // 对run方法进行重写
        @Override
        public void run() {
            System.out.println("机器人" + this.name + "正在跑");
        }
    }
    public class Test4 {
        public static void main(String[] args) {
            Robot robot1 = new Robot("图图");
            robot1.run();
        }
    }
    // 执行结果
    机器人图图正在跑

    😎只要能跑就行,管他是机器人还是动物呢😂,接口是不是很灵活呀!

    同时在实际的开发过程中,一般来说,一个类是一个Java文件,一个接口也是一个Java文件。大家也要在平时就养成这个好习惯呀!

    哈哈,不知道现在你对抽象类和接口的认识是不是又上升了一个高度呢?嘻嘻,我们下篇博客再见了,下篇让我们瞅瞅Java中常用的接口有哪些😉

     每天进步一点点,铁汁们,一起加油😎😎😎

    展开全文
  • .NET常用类接口

    2013-05-19 16:23:21
    .NET常用类接口
  • 常用接口分类

    千次阅读 2021-07-19 11:02:01
    先言:接口分为程序内部使用的接口和系统对外交流的传输接口。一般情况下,我们口头说的接口都是后者。 HTTP接口:基于HTTP协议的开发接口.这个并不能排除没有使用其他的协议。 API接口:API(Application ...
  • java中常用接口、包

    千次阅读 2019-02-27 21:28:23
    常用包括: Object、String、Math、Thread、Date、File。 常用接口: List、Map、Runnable、collection、comparable。 常用的包: java.lang.包; java.util.包; java.io.包; java.math.包; Java集合框架:...
  • java.sql包中的类和接口及其使用

    千次阅读 2021-02-26 20:52:05
    下面,详解java.sql包中包含的常用接口和类1、DriverManager负责管理JDBC驱动程序,使用JDBC驱动程序之前,必须先将驱动程序加载并向DriverManager注册后才可以使用,同时提供方法来建立与数据库的连接。常用...
  • 普通,抽象类和接口之间的区别

    千次阅读 热门讨论 2020-01-30 18:06:21
    一、普通、抽象类和接口区别: 1. 普通可以实例化,接口都不能被实例化(它没有构造方法),抽象如果要实例化,抽象必须指向实现所有抽象方法的子类对象(抽象可以直接实例化,直接重写自己的抽象方法),接口...
  • 抽象类和接口有什么异同?

    千次阅读 2018-12-23 14:48:42
    2.接口的实现类或者抽象的子类都必须实现类接口或者继承了抽象才可以被实例化 不同点: 1.接口只有定义,方法不能再接口中实现,实现接口的类要实现接口中的所有方法;抽象类可以有定义与实现方法可以在抽象类中实现...
  • Spring常用接口和类

    千次阅读 2018-03-18 23:26:29
    ApplicationContextAware接口 ...通过工具直接实现该接口,返回ApplicationContext对象。 实现 @Component public class SpringContextUtil implements ApplicationContextAware{ priv...
  • JDBC常用接口和类

    万次阅读 2016-04-08 18:56:56
    DriverManager:用于管理JDBC驱动的服务。程序中使用该的的主要功能是获取Connection对象,该包含如下方法: public static Connection getConnection(String url, String user, String password) throws ...
  • JDBC 中常用类和接口 在 Java 语言中提供了丰富的类和接口用于数据库编程,利用这些类和接口可以方便的进行数据访问处理。 Collection 接口 Collection 接口代表与特定的数据库的连接,在连接上下文中执行 SQL ...
  • 接口和抽象的区别

    万次阅读 多人点赞 2018-08-12 21:38:36
    接口和抽象有什么区别 你选择使用接口和抽象的依据是什么? 接口和抽象的概念不一样。接口是对动作的抽象,抽象是对根源的抽象。 抽象表示的是,这个对象是什么。接口表示的是,这个对象能做什么。...
  • Java——接口与实现

    千次阅读 2021-09-15 19:54:56
    定义接口包含接口声明和接口接口体:常量声明(final)抽象方法(abstract)。             (没有变量,没有普通方法) 所有常量的访问权限一定都是...
  • Spring常用接口和类(一)

    千次阅读 2016-07-10 17:56:31
    介绍以下类接口:  ApplicationContextAware接口、ApplicationEvent抽象类、ApplicationListener接口、BeanNameAware接口、InitializingBean接口、DisposableBean接口   一、ApplicationContextAware接口...
  • SpringMVC中常用的视图接口分类及对应的实现: URL资源视图:InternalResourceView、JstlView 文档视图:AbstractExcelView、AbstractPdfView 报表视图:ConfigurableJsperReportsView等JasperReports报表技术...
  • 查找接口的实现: IDEA 风格 ctrl + alt +B IDEA快速实现接口快捷方式 ALT +INSERT 例如:查看Subject接口的实现; 一.常用快捷键(这些我们经常用) Alt + Enter 引入 Ctrl + O 查看我们继承的...
  • 抽象接口常用关键字

    千次阅读 2019-03-11 11:24:00
    抽象格式:abstract class 类名{} 抽象方法格式:public abstract void eat();
  • 而抽象和接口正是我们工作中常用的用以解决具体实现变化的一种方式,它为我们提供了:“将接口和实现分离的方法”。这样,我们编码过程就可以面向接口而不是面向实现编程,这样当具体实现发生变化时,上游系统将...
  • java的常用接口有哪些?

    千次阅读 2021-02-12 15:49:20
    展开全部常用接口e5a48de588b63231313335323631343130323136353331333431336661种类,具体如下。1.java.lang.StringString无可争议的获得冠军,应该没有人会否认这一点,这是一个最终,用于创建/操作不可变的...
  • http接口调用常用Response返回

    千次阅读 2022-03-19 17:40:29
    http接口调用常用Response返回
  • JDBC中常用的的类和接口

    千次阅读 2016-06-02 23:42:44
    Connection接口代表与特定的数据库连接,在连接上下文中执行SQL语句并返回你输入命令的结果 1 Statement接口,用于已经建立连接的基础上想数据库发送Sql语句,在JDBC中有三种Statement,PreparedStatement,...
  • C++接口类

    千次阅读 2019-03-12 21:39:04
    在C++中仅含有纯虚函数的成为接口类,也就是没有数据成员 只有纯虚函数的成员函数 例如~ class Shape { public: virtual double calcArea()=0; virtual double calcPerimeter()=0; } 接口类呢更多的是一种...
  • java中接口和抽象的区别

    万次阅读 多人点赞 2018-09-21 23:18:35
    接口和抽象的区别? 接口(interface)和抽象(abstract class)是支持抽象定义的两种机制。 接口是公开的,不能有私有的方法或变量,接口中的所有方法都没有方法体,通过关键字interface实现。 抽象是可以有...
  • 常用:BufferedReader BufferedWriter FileReader FileWirter String Integer java.util.Date, Class, HashMap 常用接口 List Map Document NodeList Servlet, , HttpServletResponse, ...
  • Java 枚举类和自定义枚举类和enum声明及实现接口1.枚举1.枚举的属性2.自定义枚举2.Enum枚举3.实现接口的枚举 1.枚举 注: JDK1.5之前需要自定义枚举 JDK 1.5 新增的 enum 关键字用于定义枚举 ...
  • Java中常用,包,接口

    万次阅读 多人点赞 2018-05-23 20:48:05
    Java中常用,包,接口包名说明java.lang该包提供了Java编程的基础,例如 Object、Math、String、StringBuffer、System、Thread等,不使用该包就很难编写Java代码了。java.util该包提供了包含集合框架、遗留的...
  • 目前显示部分常用接口部分整理与总结 1.HDMI:是一种全数字化视频声音发送接口,可以发送...这类接口在智能电视、机顶盒、投影仪等设备中比较常见,其接口呈倒梯形,较偏平;如下图:(HDMI2.0) HDMI 1...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 835,445
精华内容 334,178
关键字:

常用的类和接口