一、接口
八种基本数据类型：
整数类型：byte、short、int、long；浮点型：float、double；char；boolean。
三种引用数据类型：
数组[]；
类：class；
接口：interface。
1：有些时候需要描述一组功能。而不是某种类型的对象。（面向功能开发）。
2：使用接口可以实现变相的多重继承。而且还不存在c++多重继承带来的隐患。
3：使用接口同样可以实现多态。
接口的语法：
[权限修饰符] interface 接口名{
// 接口体
}
例1：
//举办一个飞行比赛 参赛者 有 飞机、超人、石头、鸟。
//关注的是功能层面的。
//需要用同一种类型来处理这四个参赛者。 使用一个数组来管理这四个参赛者
public class TestInterface {
public static void main(String[] args) {
Flyable[] flyables = new Flyable[4];
flyables[0] = new Bird();
flyables[1] = new SuperMan();
flyables[2] = new Stone();
flyables[3] = new Plane();
for(int i=0;i
flyables[i].fly();
}
}
}
//描述飞行的功能
interface Flyable{
abstract void fly();
}
//无实意，为了演示变相多重继承
class Animal{
}
//变相的多重继承
class Bird extends Animal implements Flyable{
public void fly() {
System.out.println("小鸟扑棱着翅膀，飞过了树梢！");
}
}
class SuperMan implements Flyable{
@Override
public void fly() {
System.out.println("超人内裤外穿，穿着披风，双手握拳伸向前方，飞向了外太空！");
}
}
class Stone implements Flyable{
@Override
public void fly() {
System.out.println("石头被人扔出了十几米远，在空中划出了一道美丽的弧线！");
}
}
class Plane implements Flyable{
@Override
public void fly() {
System.out.println("飞机屁股冒着烟在平流层飞行！");
}
}
例2：
public class TestUsb {
public static void main(String[] args) {
Computer computer = new Computer();
Fun fun = new Fun();
LedLight ledLight = new LedLight();
computer.load(fun);
computer.load(ledLight);
}
}
class Computer{
//定义一个装载USB设备的方法
void load(Usb usb){
usb.run(this);
}
}
//描述usb功能
interface Usb{
//描述通过usb 接口如何让设备运转起来
void run(Computer computer);
}
class Fun implements Usb{
@Override
public void run(Computer computer) {
System.out.println("通过usb 小风扇转了起来，吹出了凉爽的风！");
}
}
class LedLight implements Usb{
@Override
public void run(Computer computer) {
System.out.println("通过usb LED 小台灯，发出了温馨的光芒！");
}
}
二、接口总结
定义：接口是一组终态静态公有的成员变量（出现比较少）和抽象公有的方法的集合。
接口特点：
1：接口中定义的变量只能是 静态的终态的公有的变量。而且public static final 都可以省略。
2：接口中不能包含代码块、构造块、静态代码块。
3：接口中不能包含构造方法。只能作为父接口使用，被子类实现。
4：接口中只能定义公有的抽象的方法（后续的jdk版本中支持了接口中方法可以自定义默认实现）。public abstract 可以省略。
5：接口往往是一组(1-n)个抽象方法的集合。
6：类是用来描述对象（往往存在属性）的，接口是用来描述一组功能（没有属性）。
7：接口可以变相的实现多重继承，是用关键字implements 。类实现某个接口，也可以实现多个接口，使用逗号分割，并可以继承某个类。
8：接口同样可以实现多态。父接口引用指向子类对象，子类必须要实现父接口的方法，最终访问的是子类的实现的方法。
9：接口定义了一组规范。接口定义的是规则。给实现的子类定义的。
在某些语言中，使用单词protocol 作为接口的关键字。协议的意思。
10：接口同样还可以继承接口使用关键字 extends。可以实现直接继承多个接口，使用逗号分割。
11：继承描述的关系是 is-a 关系。实现接口描述的是 has-a 的关系。
12：使用接口可以实现 设计（定义接口）和实现（子类实现接口）相分离。
13：接口是一种可以将某些功能混合到某些类型的主类型中去的类型。
比如：将USB接口、网线接口、电源充电器插头的这些功能类，混合到电脑这个主类上，使主类的功能增加。
例3：
//定义一个类，具有报警功能的门。
class Door {
void open(){}
void close(){}
}
//类实现接口用implements，多个接口之间用“,”隔开
class AlarmDoor extends Door implements Alarmable,SeeOutable,A,B{
public void alarm(){}
public void seeOut(){}
public void A(){}
public void B(){}
public void C(){}
}
interface Alarmable{
//公有的抽象的方法 public abstract 可以省略。
void alarm();
}
//接口继承接口用extends ，多个接口之间用“,”隔开
interface SeeOutable extends A,B{
void seeOut();
}
interface Aable{
void A();
}
interface Bable{
void B();
void C();
}
例4：
//登录注册功能大概的思路
public class TestLogin {
public static void main(String[] args) {
LoginAble login = new MyLogin();
int result = login.regist("", "");
}
}
//项目组长定义规范
interface LoginAble{
/**
* 注册用户的功能
* @param userName 要注册的用户的名字
* @param pwd 注册用户定义的密码
* @return 如果用户名不合法 返回 2，如果密码不合法 返回 3，如果用户名已经存在 返回 4，如果请求超时 返回 5 注册成功返回 1；
*/
int regist(String userName,String pwd);
/**
* 注册完成之后，登录系统
* @param userName 登录的用户名
* @param pwd 登录的密码
* @return 如果用户不存在 返回 2，如果用户名密码不匹配 返回 3，如果登录超时 返回 4，登录成功返回 1；
*/
int login(String userName,String pwd);
}
//普通码农做的事情
class MyLogin implements LoginAble{
@Override
public int regist(String userName, String pwd) {
// TODO Auto-generated method stub
return 1;
}
@Override
public int login(String userName, String pwd) {
// TODO Auto-generated method stub
return 1;
}
}
三、冒泡排序
例：
import java.util.Arrays;
import com.bjsxt.util.MyUtil;
/**
* 冒泡排序
*
*/
public class TestBubble {
public static void main(String[] args) {
test1();
}
static void test1(){
int[] array = new int[10];
for(int i=0;i
array[i] = MyUtil.getRandomNumber(0, 30);
}
System.out.println(Arrays.toString(array));
bubbleSort(array);
System.out.println(Arrays.toString(array));
}
//自定义方法，实现对指定的数组进行冒泡排序
//排序优化，如果待排序区已经是一个有序的序列，就不需要再排序了。
//如何知道待排序区是一个有序的序列。
public static void bubbleSort(int[] array){
for(int i=0;i
//判断待排序区是否是一个有序的序列
boolean flag = false;
for(int j=0;j
if(array[j] > array[j+1]){
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
//在整个内层循环中都没有执行到 flag=true，说明 判断条件都没有成立。
//说明待排序区是一个有序的序列，直接结束方法即可。
if(!flag){
return;
}
}
}
public static void test2(){
Student[] students = new Student[10];
for(int i=0;i
students[i] = new Student(MyUtil.getRandomNumber(10, 19), MyUtil.getRandomNumber(60, 101), "佩奇");
}
System.out.println(Arrays.toString(students));
bubbleSort(students);
System.out.println(Arrays.toString(students));
}
/**
* 根据学生的分数升序排列
* @param array
*/
public static void bubbleSort(Student[] array){
for(int i=0;i
boolean flag = false;
for(int j=0;j
if(array[j].getScore() > array[j+1].getScore()){
Student temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
//在整个内层循环中都没有执行到 flag=true，说明 判断条件都没有成立。
//说明待排序区是一个有序的序列，直接结束方法即可。
if(!flag){
return;
}
}
}
}
//测试的Student类
class Student{
private int age;
private int score;
private String name;
Student(int age, int score, String name) {
super();
this.age = age;
this.score = score;
this.name = name;
}
public Student() {
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "\nStudent [age=" + age + ", score=" + score + ", name=" + name + "]";
}
}
四、自定义内部比较器
//定义接口使类数组中需要比较的对象自身拥有比较的方法功能
import java.util.Arrays;
import com.bjsxt.util.MyUtil;
/**
* 内部比较器练习
*
*/
public class TestComparable {
public static void main(String[] args) {
test();
}
/**
* 根据学生的分数升序排列
* 内部比较器
* @param array
*/
public static void bubbleSort(Student[] array){
for(int i=0;i
boolean flag = false;
for(int j=0;j
if(array[j].compareTo(array[j+1]) > 0){
Student temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
//在整个内层循环中都没有执行到 flag=true，说明 判断条件都没有成立。
//说明待排序区是一个有序的序列，直接结束方法即可。
if(!flag){
return;
}
}
}
public static void test(){
Student[] students = new Student[10];
for(int i=0;i
students[i] = new Student(MyUtil.getRandomNumber(10, 19), MyUtil.getRandomNumber(60, 101), "佩琪");
}
System.out.println(Arrays.toString(students));
bubbleSort(students);
System.out.println(Arrays.toString(students));
}
}
//使用接口实现---内部比较器
//定义接口，描述比较功能--当前对象和传入的对象两者比较大小。
interface MyComparable{
/**
* 用于比较当前对象和 o 谁大谁小。
* @param o 用于比较的对象
* @return 如果当前对象比o大，返回正数，如果比o 小，返回负数，否则返回0
*/
int compareTo(Object o);
}
class Student implements MyComparable{
private int age;
private int score;
private String name;
Student(int age, int score, String name) {
super();
this.age = age;
this.score = score;
this.name = name;
}
public Student() {
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "\nStudent [age=" + age + ", score=" + score + ", name=" + name + "]";
}
@Override
public int compareTo(Object o) {
//强转成Student类型
Student s = (Student)o;
int result = this.age - s.age;
if(result == 0){
return this.score-s.score;
}
return result;
}
}
五、自定义外部比较器
import java.util.Arrays;
import com.bjsxt.util.MyUtil;
/**
* 外部比较器练习
*
*/
public class TestComparator {
public static void main(String[] args) {
test();
}
public static void test(){
Student[] students = new Student[10];
for(int i=0;i
students[i] = new Student(MyUtil.getRandomNumber(10, 19), MyUtil.getRandomNumber(60, 101), "佩琪");
}
System.out.println(Arrays.toString(students));
AgeComparator ageComparator = new AgeComparator();
bubbleSort(students,ageComparator);
System.out.println(Arrays.toString(students));
}
/**
* 根据学生的分数升序排列
* 外部比较器
* @param array
*/
public static void bubbleSort(Student[] array, MyComparator comparator){
for(int i=0;i
boolean flag = false;
for(int j=0;j
//if(array[j].compareTo(array[j+1]) > 0){
if(comparator.compare(array[j], array[j+1]) > 0){
Student temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
//在整个内层循环中都没有执行到 flag=true，说明 判断条件都没有成立。
//说明待排序区是一个有序的序列，直接结束方法即可。
if(!flag){
return;
}
}
}
}
//外部比较器接口
interface MyComparator{
/**
* 用于比较两个对象的大小
* @param o1 比较对象 1
* @param o2 比较对象 2
* @return 如果o1 大于 o2 返回 正数， 否则 返回 负数 ，相等返回 0
*/
int compare(Object o1, Object o2);
}
/**
* 根据学生年龄进行排序的外部比较器
*/
class AgeComparator implements MyComparator{
@Override
public int compare(Object o1, Object o2) {
Student s1 = (Student)o1;
Student s2 = (Student)o2;
return s1.getAge()-s2.getAge();
}
}
/**
* 根据学生成绩进行排序的外部比较器
*/
class ScoreComparator implements MyComparator{
@Override
public int compare(Object o1, Object o2) {
Student s1 = (Student)o1;
Student s2 = (Student)o2;
return s1.getScore()-s2.getScore();
}
}
class Student{
private int age;
private int score;
private String name;
Student(int age, int score, String name) {
super();
this.age = age;
this.score = score;
this.name = name;
}
public Student() {
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "\nStudent [age=" + age + ", score=" + score + ", name=" + name + "]";
}
}
