**java** 学习笔记

java 学习笔记

void关键字

学过Java的人都知道void的意思是空，如果你去问老手，老手会告诉你说：“void什么都不是，你只要记住void就是空，在方法申明的时候表示该方法没有返回值”。

那么java中的void到底是什么类型呢？ 其实void也有对应的包装类java.lang.Void，不过我们无法直接对它们进行操作。 它继承于Object，如下：

public final class Void extends Object {

/*

• The Void class cannot be instantiated.

*/

private Void() {}

}

Void类和String类一样 被定义为final，所以不能扩展；另外，它的构造方法被私有化了所以不可实例化。

Void类是一个不可实例化的占位符类，用来保存一个引用代表了Java关键字void的Class对象。

数据结构

8种基本数据类型

数据类型 type 包装类

基本类型 byte java.lang.Byte

基本类型 short java.lang.Short

基本类型 int java.lang.Integer

基本类型 long java.lang.Long

基本类型 float java.lang.Float

基本类型 double java.lang.Double

基本类型 char java.lang.Character

基本类型 boolean java.lang.Boolean

引用类型：
Class、

Collection集合类、

自定义类

。。。

Java中抽象类和接口的用法和区别

一、抽象类

1、抽象类

包含一个抽象方法的类就是抽象类

2、抽象方法

声明而未被实现的方法，抽象方法必须使用abstract关键词字声明

public abstract class People { //关键词abstract，声明该类为抽象类

public int age;

public void Num() {

}

public abstract Name(); //声明该方法为抽象方法

}

3、抽象类被子类继承，子类（如果不是抽象类）必须重写抽象类中的所有抽象方法

4、抽象类不能被直接实例化，要通过其子类进行实例化

5、只要包含一个抽象方法的抽象类，该方法必须要定义成抽象类，不管是否还包含有其他方法。

6、子类中的抽象方法不能与父类的抽象方法同名。

7、abstract不能与final并列修饰同一个类。

8、abstract 不能与private、static、final或native并列修饰同一个方法。

二、接口

接口，英文称作interface，在软件工程中，接口泛指供别人调用的方法或者函数。在Java中它是对行为的抽象。

接口中可以定义 变量和方法。

接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误）。

接口中的方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误），

接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。

接口的格式

interface interfaceName{

全局常量

抽象方法

}

class A implements Interface1,Interface2,[....]{

... 接口的实现使用关键字implements，而且接口是可以多实现的

}

class A extends Abs implements Inter1,Inter2{ //Abs是一个抽象类

...一个类可以同时继承抽象类和接口

}

interface Inter implements Inter1,Inter2{ //Inter、Inter1、Inter2都为接口

...接口能通过extends关键字继承多个接口

}

三、抽象类和接口区别

语法层次

public abstract class People { //关键词abstract，声明该类为抽象类

void Num();

abstract void Name(); 　　　//声明该方法为抽象方法

}

Interface Person {

void Num();

void Name();

}

抽象类方式中，抽象类可以拥有任意范围的成员数据，同时也可以拥有自己的非抽象方法，

但是接口方式中，它仅能够有静态、不能修改的成员数据（但是我们一般是不会在接口中使用成员数据），同时它所有的方法都必须是抽象的。

在某种程度上来说，接口是抽象类的特殊化。

对子类而言，它只能继承一个抽象类（这是java为了数据安全而考虑的），但是却可以实现多个接口。

设计层次

1、 抽象层次不同

抽象类是对类抽象。

接口是对行为的抽象。

抽象类是对整个类整体进行抽象，包括属性、行为。

接口却是对类局部（行为）进行抽象。

2、 跨域不同

抽象类所跨域的是具有相似特点的类，而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分，然后泛化成抽象类，子类继承该父类即可，

但是接口不同。实现它的子类可以不存在任何关系，共同之处。例如猫、狗可以抽象成一个动物类抽象类，具备叫的方法。鸟、飞机可以实现飞Fly接口，具备飞的行为，这里我们总不能将鸟、飞机共用一个父类吧！所以说抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a" 关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的， 仅仅是实现了接口定义的契约而已。

3、 设计层次不同

抽象类是自下而上来设计的，我们要先知道子类才能抽象出父类。

接口不需要知道子类的存在，只需要定义一个规则即可，至于什么子类、什么时候怎么实现它一概不知。

比如我们只有一个猫类在这里，如果你这是就抽象成一个动物类，是不是设计有点儿过度？我们起码要有两个动物类，猫、狗在这里，我们在抽象他们的共同点形成动物抽象类吧！所以说抽象类往往都是通过重构而来的！

但是接口就不同，比如说飞，我们根本就不知道会有什么东西来实现这个飞接口，怎么实现也不得而知，我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。

门和警报的例子

门都有open( )和close( )两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念。

abstract class Door {

public abstract void open();

public abstract void close();

}

or：

interface Door {

public abstract void open();

public abstract void close();

}

给门延伸报警****alarm****(****)的功能，那么该如何实现？

放在抽象类里面：

但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；

放在接口里面：

需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。

从这里可以看出， Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。

最好的解决办法：

单独将报警设计为一个接口，包含alarm()行为。

Door设计为单独的一个抽象类，包含open和close两种行为。

再设计一个报警门继承Door类和实现Alarm接口。

interface Alram {

void alarm();

}

abstract class Door {

void open();

void close();

}

class AlarmDoor extends Door implements Alarm {

void oepn() {

  //....

}

void close() {

  //....

}

void alarm() {

  //....

}

}

抽象类和接口的区别

说到抽象类和接口，就必须要说到类。

一个类就是对现实事物的抽象。

比如定义一个BenzCar类，就需要对现实的奔驰汽车有很好的抽象(当然奔驰汽车有好多系列，这里不钻牛角尖)。也就是说如果你要造一辆奔驰汽车，就需要BenzCar这个类(这辆奔驰汽车就是内存中的一个Instance)。

那么抽象类就是对类的抽象。

怎么理解呢?就是说有很多汽车厂商一起定义一种规范(Car类)，说要造一辆汽车就需要有发动机，轮胎，音响设备…(这些就相当于抽象方法)，具体用什么发动机，轮胎，音响设备由每个汽车厂商自己去完成。这样就有各种汽车了，奔驰牌的，宝马牌的，丰田牌的…

接口就是对抽象类的抽象

这只是我个人的理解。

在我们日常生活中可以看到各种“接口”，电源插座就是一种。开始我是看到耗子叔的博客在开始理解“控制翻转”这个概念的——IoC/DIP其实是一种管理思想| 酷壳- CoolShell.cn。后来我就想，这个东西其实无处不在，制造电源插座的厂和制造电器的厂只要约定一种“接口”——两口插座或三口插座，当然每个国家的接口都不一样，不同接口之间的转换就需要用适配器了。

其实程序中也一样，比如所有的交通工具可以抽象为一个接口Drivable(可能由于经验原因，我考虑的不是很完善)，表示实现这个接口的类创建的对象(比如：汽车，飞机，轮船等等)都是可以驾驶的public interface Drivable{ public void drive; }然后，我们就可以创建一个AbstractCar类，表示这个对所有汽车类的一个抽象，所有可以驾驶的汽车都必须继承这个类，这个抽象类中规定了一些抽象方法，比如getEngine当然，你也可以继承AbstractCar类，对所有可能具有相同引擎的汽车进行一层抽象)。drive设为abstract。这两种实现方式，我觉得从功能上讲是一样的，但是从类设计上讲是不同的。下面代码中的实现，我是参考了java.util.AbstractList* @throws UnsupportedOperationException * if adding to this List is not supported.public abstract class AbstractCar implements Drivable { public abstract Engine getEngine; public abstract Wheel getWheel; @Override public void drive{ throw new UnsupportedOperationException; } // 省略其他方法和属性 }默认情况下“汽车”是不能开的，你实现了一个汽车类后，需要Override这个方法，实现自己的drive方法以java容器中的List举例

到源码里面找，你就会发现的继承关系最顶层的就是Iterable，就表示说List是可以遍历的，而且它还会产生一个Iterator接口对象。这表示一个列表可以通过这个迭代器来遍历。

这就像上面说的，所有的交通工具都是可以驾驶的一样，所有的列表都是可以遍历的。

一层一层往下，类就变得更加具体。

最后

为什么接口可以继承?

其实这个原理很简单。因为总有一个最本质的协议来约束大家，比如所有的交通工具都是可以驾驶的，所有的容易都是可以遍历的。然后协议会渐渐变得更加具体：

Iterable <- Collection <- List <- AbstractList <- List

从下往上看，就是一层比一层抽象。

抽象类的子类不能再继承其他的类,可以实现多个接口.因为java是单继承的.

如果说目前有一个类已经继承(extends)其他类了,如果这个时候又有一个父类出现,那么只能定义为他的父类为接口,不能定义为抽象类

抽象类中除了能定义抽象方法以外,也可以定义具体的方法,并且可以定义方法体内容.

接口中是不可以定义具体的方法实现,他只能允许你定义方法但是不能有任何方法体.

概念上的区别:

抽象类:如果一个类中没有包含足够的信息来描述一个具体的对象,这样的类就是抽象类.接口是一种特殊的抽象类.可以这么理解,接口是抽象类的一种特殊表现,有自己的一套规范约束在里面.

实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。

标记接口

最常用的继承接口是没有包含任何方法的接口。

标识接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

标识接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。

例如：java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下：

package java.util;

public interface EventListener

{}

没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：

• 建立一个公共的父接口：正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
• 向一个类添加数据类型：这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

java 中的字符串

Java中String、StringBuffer、StringBuilder和toString的介绍

一、String类

1、字符串长度——length（）

String str = "coder";

System.out.print(str.length());

输出结果：

5

2、字符串转换数组——toCharArray（）

String str = "coder";

char data[] = str.toCharArray(); //调用String类中toCharArray方法

for (int i = 0; i < data.length; i++){

System.out.print(data[i]+" "); //加入空格，以示区分

}

输出结果：

c o d e r

3、从字符串中取出指定位置的字符——charAt()

String str = "coder";

System.out.print(str.charAt(3));

输出结果：

e

4、字符串与byte数组的转换——getBytes()

String str = "coder";

byte bytes[] = str.getBytes();

for (int i = 0; i < bytes.length; i++){

System.out.print(new String(bytes)+"\t"); //加入换行，以示区分

}

输出结果：

coder

coder

coder

coder

coder

5、过滤字符串中存在的字符——indexOf()

String str = "coder@163.com";

System.out.print(str.indexOf("@"));

输出结果：

5

6、去掉字符串的前后空格——trim()

String str = " coder@163.com ";

System.out.print(str.trim());

输出结果：

coder

7、从字符串中取出子字符串——subString()

8、大小写转换——toLowerCase()、toUpperCase()

9、判断字符串的开头结尾字符——endWith()、startWith()

10、替换String字符串中的一个字符——replace()

二、StringBuffer类

1、认识StringBuffer:

缓冲区、本身也是操作字符串，但是与String不同，StringBuffer是可以更改的。StringBuffer也是一个操作类，所以必须通过实例化进行操作

2、StringBuffer常用方法：

append()

insert()

replace()

indexOf()

举例：

StringBuffer str = new StringBuffer();

str.append("coder");

system.out.print(str.toString());

输出结果：

coder

三、StringBuilder类

1、认识StringBuilder:

一个可变的字符序列，该类被设计作用StringBuffer的一个简易替换，用在字符串缓冲区被单个线程所使用的时候。建议优先考虑该类，速度比StringBuffer要快

2、但是如果涉及到线程安全方面，建议使用StringBuffer

2、StringBuilder常用方法：

append()

insert()

replace()

indexOf()

四、toString()方法

因为它是Object里面已经有了的方法，而所有类都是继承Object，所以“所有对象都有这个方法”。它通常只是为了方便输出，比如System.out.println(xx)，括号里面的“xx”如果不是String类型的话，就自动调用xx的toString()方法。总而言之，它只是sun公司开发java的时候为了方便所有类的字符串操作而特意加入的一个方法。

举例：

1

2

3

4

5

6 StringBuffer str = new StringBuffer();

str.append("coder");

system.out.print(str.toString());

输出结果：

coder