接口

  一、接口的基本概念
  关键字为:Interface,在JAVA编程语言中是一个抽象类型,是抽象方法的集合。也是使用.java文件编写。
 
二、接口声明

  命名规范:与类名的命名规范相同,通常情况下以大写字母 I 开头,与类作于区分。接口的访问修饰符只能使用public或者缺省修饰,不能使用protected和private修饰。
 
  接口中的所有属性只能是公开的静态的常量: public static final 数据类型 属性名 ;(public/static/final可以省略)
 
  接口中的所有方法必须是公共的抽象方法,而且接口中的抽象方法也可以省略public/abstract关键字。写法:public abstract 返回值类型 方法名();
三、接口的使用
一个类实现接口使用implements关键字,实现类实现接口必须重写接口中的所有方法,除非实现类也是个抽象类。(可以多实现接口,多个接口之间用逗号隔开)。
class 实现类  implements  接口1,接口2{//某类实现了两个接口
@Override
public void print() {
System.out.println("接口1的抽象方法print()");
}
@Override
public void get() {
System.out.println("接口2的抽象方法get()");
}
}
四、接口的引用

  接口的引用可以指向实现类的对象,类似于父类引用指向子类对象。
  例如: ITest t = new TestImpl();
五、接口的继承
在Java中,一个接口可以使用extends关键字同时继承多个接口,当实现类在实现C接口的时候需要重写接口C和其父类接口A和接口B的方法。
例如:
interface A{
public void funA();
}
interface B{
public void funB();
}
interface C extends A,B{//C接口同时继承了A和B两个接口
public void funC();
}
六、接口优点
(1).可以被多继承
(2).设计和实现完全分离
(3).更自然的使用多态
(4).更容易搭建程序框架
(5).更容易更换实现
七、抽象类和接口的区别
(1).本质区别:class和interface关键字不同。 抽象类是类,接口是一种规范。子类继承抽象类,要求子类必须和父类是一类事物,必须符合"is a"关系,例如:Chinese is a people。接口只是对功能的拓展,多个实现类实现接口时并不要求所有的实现类是一类事物。接口符合"like a"关系,理解为"XX具备什么样的功能"。
(2).接口可以多继承多实现,抽象类只能单继承。
(3).抽象类可以有自己的属性,接口中只能有静态常量。
(4).接口中的方法必须是抽象方法,抽象类可以有非抽象方法。(接口中的抽象方法可以省略abstract)

        (5).抽象类是类,接口是一种规范。

子类继承抽象类,要求子类必须和父类是一类事物
接口并不要求多个实现类是同一类事物,只是进行设计与实现的分离。

集合框架

一、集合框架体系图

二、四个接口的区别
collection:存储不唯一、无序的数据。
list:存储有序的、不唯一的数据。记录先后添加的顺序。
set: 存储无序的、唯一的数据。不记录先后添加多少顺序。
map: 以键值对的形式存储数据,以键取值,键不可以重复,值可以重复。
三、List以及List子类和常用方法
    ArrayList :是数组结构,长度是可变的,ArrayList不是线程安全的。
    LinkedList:是基于双向循环链表实现的,是链表结构。
    Vector : 线程安全的,其他的月ArrayList类似
  1.常用方法:
(1)add(E e):在列表的末尾插入元素
(2)add(int i,E e): 在列表指定位置插入元素。
(3)size():返回当前列表的长度。
(4)get(int index):返回下标为index的元素,如果没有泛型的约束,需要强转,如果有泛型的约束无需强转。
(5)clear():移除此列表中的所有元素。
(6)contains():传入一个对象,检测列表中是否包含该对象,如果此列表中包含指定的元素,则返回 true。(如果传入的是String和基本数据类型可以直接比对,如果传入的是实体对象,则默认只比对两个对象的地址,因此在实体类中重写equals()方法)
(7)isEmpty():如果此列表中没有元素,则返回 true。
(8)remove(int index): 移除列表中制定位置的元素,如果下标大于size,会报下标越界异常。
(9)remove(object o): 要求重写equals方法,返回true或false,移除列表中第一次出现的元素。
(10)removeRange(int fromIndex, int toIndex):移除列表中索引在 fromIndex(包括)和 toIndex(不包括)之间的所有元素。
(11)indexof(object o):传入一个对象,返回该对象在列表中首次出现的地址。
(12)lastIndexof(object o):传入一个对象,返回该对象在列表中最后一次出现的地址。
(13)set(int index, E e): 用指定的元素替代此列表中指定位置上的元素。
(14)subList(fromIndex, toIndex):截取一个子列表,fromIndex(包括)和 toIndex(不包括)之间的所有元素,返回List类型。
(15)toArray():将列表返回一个object类型的数组。
2.遍历列表
1.使用for循环遍历列表
2.使用foreach循环遍历列表
3.使用迭代器遍历列表(iterator)
使用列表调用iterator()方法,返回一个迭代器对象。
使用迭代器调用hasNext()方法,判断是否有下一条数据。
使用迭代器对象调用next()方法,取出下一条数据。
ArrayList<String> strings = new ArrayList<String>();
strings.add("123");
strings.add("345");
Iterator<String> iterator = strings.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
System.out.println(s);
}

  3.ArrayList和LinkedList的区别

1) ArrayList 实现了一个长度可变的数组,在内存空间中开辟一块空间,和数组的区别是长度可以随时修改。这种循环遍历和随机访问元素的速度比较快。LinkedList 使用链表结构存储数据,在插入和删除元素时比较快。
2) LinkedList特有的方法:
addFirst()和addLast(),分别是开头插入元素和结尾插入元素。
removeFirst()和removeLast(),删除第一个元素或者最后一个元素,并返回删除的元素。
getFirst()和getLast(),查询第一个元素或者最后一个元素,并返回查找到的元素。
   四、Set以及Set子类和常用方法
    1.常用方法: 与List接口基本相同,但是由于set接口中的元素是无序的,因此没有与下标相关的方法。例如:get(index),remove(index),add(index,E e)。
 
    2.Set集合的特点: 唯一、无序。
    3.Set集合的遍历方式:
  (1)foreach循环遍历。
  (2)迭代器遍历(iterator)。
Iterator<String> iterator = hashSet.iterator();
      while (iterator.hasNext()) {
     System.out.println(iterator.next());
     }
    4.HashSet: 底层是调用HashMap的相关方法,传入数据后,根据数据的hashCode进行散列运算,得到一个散列值后再进行运算,确定元素在序列中的位置。
    HashSet如何确定一个对象是否想等?
     先判断元素的哈希值(hashcode()),如果哈希值不同,肯定不同一个对象,如果哈希值相同,重写equals()方法,再次判断元素的内容是否相同,如果equlas返回true,意味着两个元素相同,如果返回的是false,意味着两个元素不相同,继续通过算法算出位置进行存储。
    所以使用HashSet存储实体对象时,必须重写对象的HashCode()和equals()两个方法。
    5.LinkedHashSet: 在HashSet的基础上,新增了一个链表,用链表来记录HashSet中元素放入的顺序,因此使用迭代器遍历的时候,可以按照放入的顺序进行打印输出。
 
    6.TreeSet:将存入的元素进行排序,然后再输出。
      ①如果存入的是实体对象,那么实体类需要实现comparable接口,并重写compareTo()方法。
Class Person implmments Comparable {
    @Override
  public int compareTo(Object obj) {
Person p = (Person) obj;
if (this.age > p.age) {
return 1;
}else if (this.age < p.age) {
return -1;
}else{
      return 0;
      }
}
}
       ②可以在实例化TreeSet的同时,通过构造函数传入一个比较器(比较器:一个实现了comparator接口,并重写其方法。)
Set<Person> hashSet = new TreeSet<Person>(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge()-02.getAge();
}
});
       ③自定义一个比较类,实现conparator()接口,并重写其方法。
TreeSet<Person> list = new TreeSet<Person>(new cp());
class cp implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
// TODO Auto-generated method stub
return o1.getAge()-02.getAge();
}
}
  五、Map以及Map子类和常用方法
    1.特点:以键值对的形式进行存储,以键取值,键不能重复,值可以重复。
 
    2.常用方法:
  (1)put(K key, V value): 在列表的末尾插入一个键值对。
  (2)get(Object key): 返回到指定键所映射的值。
  (3)clear(): 从该列表中删除所有的数据。
  (4)containsKey(Object key):如果此集合中包含指定键的映射,则返回 true 。
  (5)containsValue(Object value):如果此集合中有一个或多个键映射到制定的值,则返回 true 。
  (6)replace(K key, V value):只有当目标映射到某个值时,才能替换指定键的条目。
  (7)remove(Object key, Object value) : 仅当指定的密钥当前映射到指定的值时删除该条目。
  (8)remove(Object key) : 如果存在(从可选的操作),从该地图中删除一个键的映射。

    3.遍历map的方式:
    (1)KeySet(): 返回值是一个set集合,通过遍历每一个键得到每一个值。
Set<String> keySet = map1.keySet();
   for (String string : keySet) {
System.out.println(map1.get(string));
  }
    (2)values(): 返回值是一个collection接口的集合,直接取到的是map集合中的value值,而无法拿到key。
Collection<String> values = map1.values();
   Iterator<String> iterator = values.iterator();
   while (iterator.hasNext()) {
System.out.println(iterator.next());
   }
    (3)entrySet(): 返回此映射的所有的set集合,集合的每个值也是一个key-value的键值对形式的值。
  Set<Entry<String, String>> entrySet = map1.entrySet();
for (Entry<String, String> entry : entrySet) {
//System.out.println(entry.getKey()+"-"+entry.getValue());
System.out.println(entry);
}
entry是java给我们提供的特殊类型,其实就是一个键值对。(取键 getKey();取值 getValue())
 
    4.HashMap和Hashtable的区别:
  1.Hashtable是线程安全(线程同步)的,HashMap是线程不安全(线程不同步)的。
  2.Hashtable的key不能为null,HashMap的key可以为null。
    5.LinkedHashMap:可以使用链表,记录数据存入的次序,进入让读出的顺序与录入的顺序一致,与LinkedHashSet一致。
    6.TreeMap:按照键的顺序的进行排序后输出,如果存入的是对象排序方法与TreeSet一致。
 

Collections工具类

 collections : 是Java中专门用于操作集合的工具类。
 (1)Collections.sort(list):对集合中的数据进行排序。
如果集合存储的是一个实体对象,那么:
1.实体类实现comparable接口,并重写CompareTo方法
2.在sort第二个参数,传入比较器,需要实现comparator接口,并重写compare方法
  (2)Collections.addAll(list, "11","2222"):向集合中添加多个数据(个数可以为多个)。
  (3)Collections.binarySearch(list, "list3"):二分法查找数据在当前集合的位置(需要先是有个sort()方法排序)。
  如果泛型是个实体类,那么:
1.就必须在实体类中实现comparable接口并重写方法后,才可以使用此方法。
2.在binarySearch第二个参数,传入比较器,需要实现comparator接口,并重写compare方法。
  (4)Collections.max(list)/Collections.min(list):返回最大最小值,如果是实体类重写比较器。
  (5)Collections.replaceAll(list, oldVal, newVal):替换内容。(需要重写equals方法)
  (6)Collections.reverse(list):反转列表中的所有元素。
  (7)Collections.shuffle(list):对集合中的元素进行随机排序。
  (8)Collections.swap(list, i, j): 将集合中的第i位置的值和j位置的值交换。
  (9)Collections.fill(list, "11111"): 将集合中的所有元素替换成一个值。

泛型 -- 参数化类型

  1.在定义类型时,不将类型定死,而是采用泛型参数进行定义,使用时传入具体的泛型参数。
 
  2.泛型类: 在声明类的时候加入泛型约束。例如:class Test<T> {private T demo;}(T可以理解成泛型声明的形参,在泛型类中,T就可以当作特殊的数据类型使用)。泛型类调用时需要将实际的数据类型传入。
 
  3.泛型类的特点: 1.泛型只在编译阶段生效,同一个类通过不同泛型拿到对象,使用getClass()判断是属于同一个类的。
2.同一个类,通过不同的泛型拿到的对象,互相互不兼容,不能互相赋值。
3.即便,声明的泛型有父子关系,但是有泛型的父子关系的泛型类也不可以互相赋值。
 
  4.泛型类在实例化的时候可以不传入泛型,类中的数据类型以赋值时传入的数据类型为主.
Test t = new Test();
t.setDemo(123);
t.setDemo("1234");
5.泛型约束时只能传入类型,可以是系统类也可以传入自己的类,但不能传入基本数据类型。
 
6.泛型约束时,可以同时约束多个泛型。
 
7.不能对确切的泛型类型使用Instanceof()方法操作。
test2 instanceof test//✔
test2 instanceof test<Integer>//✖

泛型通配符和上下边界
1.为了解决同一个类的多个不同泛型对象相互不兼容的问题,可以使用泛型通配符<?>.
2.<?>表示可以兼容所有类的数据类型。
3.泛型通配符上边界:<? extends 类名>,表示泛型通配符只支持制定类及制定类的子类。
Test<? extends Number> t = new Test<Integer>();//✔
Test<? extends Number> t = new Test<Double>();//✔
Test<? extends Number> t = new Test<String>();//✖
4.泛型通配符下边界:<? super 类名>,表示泛型通配符只支持制定类及其超类。
Test<? super Integer> t = new Test<Integer>();//✔
Test<? super Integer> t = new Test<Number>();//✔
Test<? super Integer> t = new Test<String>();//✖

泛型接口

1.声明泛型接口
interface inter<T>{
void test(T t);
}
2.实现类如果实现泛型接口,不能直接使用接口的泛型,需要重新声明
class test3<T> implements inter<T>{
@Override
public void test(T t) {
// TODO Auto-generated method stub
}
}
3.如果实现类不想作为泛型类,那么可以实现接口时直接给泛型的接口赋值。
class test3 implements inter<String>{
@Override
public void test(String t) {
// TODO Auto-generated method stub
}
}

泛型方法


1.泛型方法可以独立于泛型类,在任何类中都可以使用泛型方法

2.使用泛型方法,可以实现可变参数的方法。

3.如果在方法中声明了<T>的方法才叫泛型方法,如果在方法中使用了类的泛型,这不能称为泛型方法。
 
class test3{
public <T> void test(T t) {
System.out.println();
}
public static <T> void test1(T t) {
System.out.println();
}
public static <T> void test2(T... t) {
for(T t1 : t){
System.out.println();
}
}
}
1.调用:test3.test("String");
2.调用:test3.test2(1,true,"123");
test3.test2(nwe Integer[]{1,2,3});
注意:静态方法中不能使用类泛型,只能将静态方法单独声明成泛型方法。

Java基础学习(四)-- 接口、集合框架、Collection、泛型详解的更多相关文章

  1. JAVA基础第四章-集合框架Collection篇

    业内经常说的一句话是不要重复造轮子,但是有时候,只有自己造一个轮子了,才会深刻明白什么样的轮子适合山路,什么样的轮子适合平地! 我将会持续更新java基础知识,欢迎关注. 往期章节: JAVA基础第一 ...

  2. Java基础学习笔记十七 集合框架(三)之Map

    Map接口 通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同,如下图. Collection中的集合,元素是孤立存在的(理解为单身),向集合中存 ...

  3. [置顶] Java基础学习总结(34)——HTTP协议详解

    一.什么是HTTP协议 HTTP是hypertext transfer protocol(超文本传输协议)的简写,它是TCP/IP协议的一个应用层协议,用于定义WEB浏览器与WEB服务器之间交换数据的 ...

  4. Java基础学习总结(53)——HTTPS 理论详解与实践

    前言 在进行 HTTP 通信时,信息可能会监听.服务器或客户端身份伪装等安全问题,HTTPS 则能有效解决这些问题.在使用原始的HTTP连接的时候,因为服务器与用户之间是直接进行的明文传输,导致了用户 ...

  5. JAVA基础第五章-集合框架Map篇

    业内经常说的一句话是不要重复造轮子,但是有时候,只有自己造一个轮子了,才会深刻明白什么样的轮子适合山路,什么样的轮子适合平地! 我将会持续更新java基础知识,欢迎关注. 往期章节: JAVA基础第一 ...

  6. Java基础-引用数据类型之集合(Collection)

    Java基础-引用数据类型之集合(Collection) 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.为什么出现集合类 面向对象语言对事物的体现都是以对象的形式,所以为了方便 ...

  7. Java基础知识强化之集合框架笔记76:ConcurrentHashMap之 ConcurrentHashMap简介

    1. ConcurrentHashMap简介: ConcurrentHashMap是一个线程安全的Hash Table,它的主要功能是提供了一组和Hashtable功能相同但是线程安全的方法.Conc ...

  8. java的集合框架最全详解

    java的集合框架最全详解(图) 前言:数据结构对程序设计有着深远的影响,在面向过程的C语言中,数据库结构用struct来描述,而在面向对象的编程中,数据结构是用类来描述的,并且包含有对该数据结构操作 ...

  9. JAVA基础学习之 Map集合、集合框架工具类Collections,Arrays、可变参数、List和Set集合框架什么时候使用等(4)

    package com.itcast.test20140113; import java.util.ArrayList; import java.util.Arrays; import java.ut ...

  10. Java基础知识强化之集合框架笔记04:Collection集合的基本功能测试

    1. Collection集合的基本功能测试: package cn.itcast_01; import java.util.ArrayList; import java.util.Collectio ...

随机推荐

  1. JAVA NIO之文件通道

    1.简介 通道是 Java NIO 的核心内容之一,在使用上,通道需和缓存类(ByteBuffer)配合完成读写等操作.与传统的流式 IO 中数据单向流动不同,通道中的数据可以双向流动.通道既可以读, ...

  2. MySQL数据库学习二 MSQL安装和配置

    2.1 下载和安装MySQL软件 2.1.1 基于客户端/服务器(C/S)的数据库管理系统 服务器:MySQL数据库管理系统 客户端:操作MySQL服务器 2.1.2 MySQL的各种版本 社区版(C ...

  3. linux --> 获取进程执行时间

    获取进程执行时间 一.时间概念 在linux下进行编程时,可能会涉及度量进程的执行时间.linux下进程的时间值分三种: 时钟时间(real time):指进程从开始执行到结束,实际执行的时间. 用户 ...

  4. mybatis整合oracle 实现一对多查询 备注?

    <resultMap type="com.asiainfo.channel.model.weeklyNewspaper.WorkReportInfo" id="Wo ...

  5. JAVA入门——Generic/泛型

    在台科大的第二次JAVA作业,老师课上讲的内容是泛型. 泛型(generic),泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数.这种参数类型可以 ...

  6. react的基本使用,及常用填坑

    import React, { Component } from 'react'; import PropTypes from 'prop-types'; import './First.css'; ...

  7. C语言数据类型作业

    一.PTA实验作业 题目1:7-4 打印菱形图案 1. 本题PTA提交列表 2. 设计思路 1.定义m,n(用于计算空格数,输出"* "数),i,j,k(用于循环) 2.输入n,并 ...

  8. alpha冲刺总结随笔

    前言:前面乱乱糟糟整了一路,到最后终于可以稳定下来了.安安心心做个总结,然后把之后要做的事情都理清楚好了. 新学长似乎是个正经[并不]大腿. 看起来也不用都是一个人或者跟陈华学长两个人对半开了[突然摸 ...

  9. 201621123062《Java程序设计》第一周学习总结

    1.本周学习总结 关键词: 初步熟悉Java的基本组成.语言特点(简单性.结构中立性).运行环境.简单语法等. 关键概念之间的联系: 1.JVM是Java程序唯一认识的操作系统,其可执行文件为.cla ...

  10. Python多线程案例

    from time import ctime,sleep import threading def music(): for i in range(2): print ("I was lis ...