Java抽象与接口

抽象

• 在一个类中，如果包含抽象方法，则该类为抽象类。
• 如果一个方法只有方法声明而没有具体的方法实现，那么该方法就是抽象方法。在方法定义出使用abstract关键字对其进行修饰。
• 一旦类中定义了抽象方法，则该类也必须声明为抽象类，在定义出添加abstract关键字。示例代码如下：

public abstract class Main{
	public abstract void show();
}

• 特点：
  1. 抽象类不能被实例化，不能在外部通过new创建其实例对象。
     一个普通类继承了该抽象类，实例化子类的时候，可以通过super()来调用抽象类的构造函数。
  2. 抽象类中可以没有抽象方法，但是包含了抽象方法的类一定是抽象类。
  3. 一个普通类继承了抽象类，则该子类必须实现抽象类中的所有抽象方法。
  4. 如果继承了抽象类的子类也是一个抽象类，则不用实现父类的抽象方法。
  5. 没有抽象的构造方法，也没有抽象的静态static方法。
  6. 抽象类中可以包含非抽象的构造方法，创建子类实例对象时可以调用。

包装类

• Java 中的数据类型从本质上看可以分为两类：8种基本数据类型和引用类型。

• 包装类是 Java 提供的一组类，专门用来创建8种基本数据类型对应的对象。

• 包装类一共有8个，保存在java.lang包中。

byte			Byte

short			Short

int				Integer

long			Long

float 			Float

double			Double

char 			Character

boolean			Boolean


Object：Character、Number、Boolean

Number：Byte、Short、Integer、Long、Float、Double

• 包装类的拆箱和装箱，拆箱和装箱是包装类的特有名词。
  • 装箱是指将基本数据类型转为对应的包装类对象。
  • 拆箱是指将包装类对象转为对应的基本数据类型。

装箱

• public Type(type value)

  每个包装类都有一个有参构造函数，用来实例化包装类对象。

  示例1

• public Type(String value)/public Type(char value)

  每个包装类还有一个重载构造函数，Character 类的重载构造函数：public Type(char value)；除了 Character 类以外的其他包装类重载构造函数：public Type(String value)

  示例2

  需要注意的是，在 Boolean 类的构造函数中，当参数为 “true” 时，Boolean 值为 true，当参数不为 “true” 时，Boolean 值为 false。

• valueOf(type value)

  每个包装类都有一个静态方法 valueOf(type value)，可以将基本数据类型转为包装类类型。

  示例3

• valueOf(String value)/valueOf(char value)

  Character 有一个重载方法：public static Type valueOf(char value)，可以将 char 类型转为包装类类型。除了 Character 以外的其他包装类的重载方法：public static Type valueOf(String value)，可以将 String 类型转为包装类类型。

  示例4

  需要注意的是，Boolean.valueOf(String value)中，当 value 为"true"时，Boolean 值为true，否则为false。

拆箱

• *Value()

  每个包装类都有一个 *Value() 方法，*是包装类对应的基本数据类型的名词，通过该方法可以将包转类转为基本数据类型。

  示例5

• parse*(String value)

  除了 Character 类之外的每一个包装类都有一个静态方法可以将字符串转为基本数据类型。

  示例6

  需要注意的是，Boolean.parseBoolean(String value)中，当 value 为 true 时，Boolean 值为 true，当 value 不为 true 时，Boolean 值都为 false。

---

---

public class Test {
	public static void main(String[] args) {
		byte b = 1;
		Byte byt = new Byte(b);
		short s = 2;
		Short shor = new Short(s);
		int i = 3;
		Integer integer = new Integer(i);
		long l = 4;
		Long lon = new Long(l);
		float f = 5.5f;
		Float flo = new Float(f);
		double d = 6.6;
		Double dou = new Double(d);
		char cha = 'J';
		Character charac = new Character(cha);
		boolean bo = true;
		Boolean bool = new Boolean(bo);
		System.out.println(byt);
		System.out.println(shor);
		System.out.println(integer);
		System.out.println(lon);
		System.out.println(flo);
		System.out.println(dou);
		System.out.println(charac);
		System.out.println(bool);
	}
}

1.返回 public Type(type value)

public class Test2 {
	public static void main(String[] args) {
		Byte byt = new Byte("1");
		System.out.println(byt);
		Short shor = new Short("2");
		Integer integer = new Integer("3");
		Long lon = new Long("4");
		Float flo = new Float("5.5f");
		System.out.println(flo);
		Double dou = new Double("6.6");
		Character charac = new Character('d');
		Boolean bool = new Boolean("abc");
		System.out.println(bool);
	}
}

2.返回 public Type(String value)/public Type(char value)

public class Test3 {
	public static void main(String[] args) {
		byte b = 1;
		Byte byt = Byte.valueOf(b);
		short s = 2;
		Short shor = Short.valueOf(s);
		int i = 3;
		Integer integer = Integer.valueOf(i);
		long l = 4;
		Long lon = Long.valueOf(l);
		float f = 5.5f;
		Float flo = Float.valueOf(f);
		double d = 6.6;
		Double dou = Double.valueOf(d);
		char cha = 'J';
		Character charac = Character.valueOf(cha);
		boolean bo = true;
		Boolean bool = Boolean.valueOf(bo);
		
	}
}

3.返回valueOf(type value)

public class Test4 {
	public static void main(String[] args) {
		Byte byt = Byte.valueOf("1");
		Short shor = Short.valueOf("2");
		Integer integer = Integer.valueOf("3");
		Long lon = Long.valueOf("4");
		Float flo = Float.valueOf("5.5f");
		Double d = Double.valueOf("6.6");
		Character cha = Character.valueOf('J');
		Boolean bool = Boolean.valueOf("tom");
		System.out.println(bool);
	}
}

4.返回 valueOf(String value)/valueOf(char value)

public class Test5 {
	public static void main(String[] args) {
		Byte byt = Byte.valueOf("1");
		Short shor = Short.valueOf("2");
		Integer integer = Integer.valueOf("3");
		Long lon = Long.valueOf("4");
		Float flo = Float.valueOf("5.5f");
		Double d = Double.valueOf("6.6");
		Character cha = Character.valueOf('J');
		Boolean bool = Boolean.valueOf("tom");
		
		byte b = byt.byteValue();
		short s = shor.shortValue();
		int i = integer.intValue();
		long l = lon.longValue();
		double dou = d.doubleValue();
		char c = cha.charValue();
		boolean boo = bool.booleanValue();
		
	}
}

5.返回 *Value()

public class Test6 {
	public static void main(String[] args) {
		byte b = Byte.parseByte("1");
		short s = Short.parseShort("2");
		int i = Integer.parseInt("3");
		long l = Long.parseLong("4");
		float f = Float.parseFloat("5.5f");
		double d = Double.parseDouble("6.6");
		boolean boo = Boolean.parseBoolean("d");
		System.out.println(boo);
	}
}

6.返回 parse*(String value)

---

返回面向对象目录