69期-Java SE-010_面向对象-4-001-002

 

Byte、Short、Integer、Long、Float、Double、Character、Boolean

### 装箱和拆箱

- 装箱：将基本数据类型转为对应的包装类对象。
- 拆箱：将包装类对象转为对应的基本数据类型。

#### 装箱

- public Type(type value)

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

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

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

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

- valueOf(type value)

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

- valueOf(String value)/valueOf(char value)

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

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

#### 拆箱

- *Value()

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

- parse*(String value)

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

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



### 接口

- 什么是接口

面向接口编程的优点：

- 能够最大限度地解耦合，降低程序的耦合性，提高程序的可维护性，可扩展性。
- 使程序便于扩展。
- 有利于程序的后期维护。

接口中的方法必须全部是抽象方法，同时接口中可以定义成员变量，但是有要求：

- 不能定义 private 和 protected 修饰的成员变量，只能定义 public 和默认访问权限修饰的成员变量。
- 接口中的成员变量在定义时必须被初始化。
- 接口中的成员变量都是静态常量，即可以直接通过接口访问，同时值不能被修改。

```java
public interface MyInterface {
	public int ID = 0;
	String NAME = "";
	public void test();
}
```

实现类，创建一个普通的 Java 类，通过 implements 关键字来实现某个接口，同时在实现类中实现接口中的所有抽象方法。

```java

public class MyImplements implements MyInterface,MyInterface2{

	@Override
	public void test() {
		// TODO Auto-generated method stub
		System.out.println("实现了接口的抽象方法");
	}

	@Override
	public void test2() {
		// TODO Auto-generated method stub
		
	}
	
}
```

#### 例子

某工厂生产成品A，主要由设备A来完成生产，用程序模拟这一过程。

分别创建Factory 类和 GoodsA 类，并将 GoodsA 设置为 Factory 的成员变量，在 Factory 的业务方法中调用 GoodsA 的方法来完成生产。



### 异常

- 什么是异常？

Java中的错误大致可分为两类，一类是编译时错误，一般指语法错误；另一类是运行时错误。

异常是Java提供的专门用于处理运行时错误的一种机制，具体步骤是当程序出现错误时，会创建一个异常类对象，改对象封装了异常的信息并提交给系统，由系统转交给能处理该异常的代码进行处理。

异常可以分为两类，包括 Error 和 Exception，Error 指系统错误，由 JVM 生成，我们编写的程序无法处理。Exception 指程序运行期间出现的错误，我们编写的程序可以对其进行处理。

#### 异常的使用

异常的使用需要用到两个关键字 try 和 catch，并且这两个关键字需要结合起来使用，用 try 来监听可能会抛出异常的代码，一旦捕获到异常，生成异常对象并交给 catch 来处理，基本语法如下：

```java
try{
  //可能抛出的异常
} catch(异常对象){
  //处理异常
}
```

除了使用try、catch关键字，还需要用到finally关键字。无论程序是否抛出异常，finally代码块中的代码都会执行。

```java
public class Test9 {
	public static void main(String[] args) {
		System.out.println(test());
	}
	
	public static int test() {
		try {
			System.out.println("try...");
			return 10;
		}catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}finally {
			System.out.println("finally...");
			return 20;
		}
	}
}
```

Factory.java

public class Factory {
    private Goods goods;
    
    public Goods getGoods() {
        return goods;
    }

    public void setGoods(Goods goods) {
        this.goods = goods;
    }

    public void work() {
        System.out.println("开始生产...");
        this.goods.work();
    }
}

 

Goods.java

public interface Goods {
    public void work();
}

 

GoodsA.java

public class GoodsA implements Goods{
    @Override
    public void work() {
        System.out.println("设备A运行，生产产品A");
    }
}

 

GoodsB.java

public class GoodsB implements Goods{
    @Override
    public void work() {
        System.out.println("设备B运行，生产产品B");
    }
}

 

 GoodsC.java

public class GoodsC implements Goods {

    @Override
    public void work() {
        // TODO Auto-generated method stub
        System.out.println("设备C运行，生产产品C");
    }

}

 

 MyImplements.java

public class MyImplements implements MyInterface,MyInterface2{

    @Override
    public void test() {
        // TODO Auto-generated method stub
        System.out.println("实现了接口的抽象方法");
    }

    @Override
    public void test2() {
        // TODO Auto-generated method stub
        
    }
    
}

 

MyInterface.java

public interface MyInterface {
    public int ID = 0;
    String NAME = "";
    public void test();
}

 

MyInterface2.java 

public interface MyInterface2 {
    public void test2();
}

 

Test.java

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);
    }
}

 

  Test2.java

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);
    }
}

 

 Test3.java

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);
        
    }
}

 

Test4.java

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);
    }
}

 

Test5.java

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();
        
    }
}

 

Test6.java

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);
    }
}

 

Test7.java

public class Test7 {
    public static void main(String[] args) {
        GoodsA goodsA = new GoodsA();
        GoodsB goodsB = new GoodsB();
        GoodsC goodsC = new GoodsC();
        Factory factory = new Factory();
//        factory.setGoods(goodsA);
//        factory.setGoods(goodsB);
        factory.setGoods(goodsC);
        factory.work();
        int[] array = new int[3];
        array[3] = 3;
    }
}

 

Test8.java

public class Test8 {
    
    public void test() {
        int num = 10/0;
    }
    
}

 

Test9.java

 

public class Test9 {
    public static void main(String[] args) {
        System.out.println(test());
    }
    
    public static int test() {
        try {
            System.out.println("try...");
            return 10;
        }catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally {
            System.out.println("finally...");
            return 20;
        }
    }
}