包含类的封装，getter/setter方法。包含构造方法和构造方法的重载。包含继承，方法重写。包含抽象类和接口。包含异常处理机制。

 包含类的封装，getter/setter方法。

包含构造方法和构造方法的重载。

包含继承，方法重写。

包含抽象类和接口。

包含异常处理机制。

1. public class lianxi1 {
       public static void main(String[] args) {
   //封装对象获得他的get和set
           System.out.println("封装get，set");
           final CPU cpu = new CPU();
           cpu.setSpeed(10.0);
           cpu.getSpeed();
           PC pc = new PC();
           pc.setCpu(cpu);
       }
       
   public static  class HardDisk {
       private Double amount;
       
       public Double getAmount() {
           return amount;
       }
       
       public void setAmount(Double amount) {
           this.amount = amount;
       }
   }
       public static class CPU {
           private Double speed;
           
           public Double getSpeed() {
   //对象的getset方法
               return speed;
           }
           
           public void setSpeed(Double speed) {
               this.speed = speed;
           }
       }
       
       
       public static class PC {
           private CPU cpu;
           private HardDisk hardDisk;
           
           public CPU getCpu() {
               return cpu;
           }
           
           public PC(CPU cpu) {        //构造方法重载
               System.out.println("构造方法重载");
               this.cpu = cpu;
           }
           
           public PC() {
               System.out.println("构造方法");//构造方法
           }
           
           public HardDisk getHardDisk() {
               return hardDisk;
           }
           
           public void setHardDisk(HardDisk hardDisk) {
               this.hardDisk = hardDisk;
           }
           
           public void setCpu(CPU cpu) {
               this.cpu = cpu;
           }
           
           public void show() {
               System.out.println("CPU的速度" + cpu.getSpeed());
               System.out.println("硬盘容量" + hardDisk.getAmount());
               
           }
       }
       
       public class sun extends Father {
   //子类继承父类
           public void show() {
               System.out.println("继承");
               System.out.println("sun");
           }
       }
       
       
       public class Father {
   //定义一个父类
           int a = 1;
           
           public int getA() {
               return a;
           }
           
           public void setA(int a) {
               this.a = a;
           }
           
           public void show() {
               System.out.println("father");
           }
       }
       
       
       public abstract class chouxiang {
   //抽象类
           abstract void chouxiangfangfa();
   //抽象方法
       }
       
       public class chouxiangImpl extends chouxiang {
           @Override
           void chouxiangfangfa() {
               System.out.println("抽象方法的继承");
           }
       }
       
       interface jiekou {
   //接口
           void jiekou();
       }
       
       class jiekouImpl implements jiekou {
           //实现接口
           @Override
           public void jiekou() {
               System.out.println("接口实现");
           }
       }
       
       
       class MyException extends Exception {
           //自定义异常继承异常
           public void show() {
               super.getMessage();
               System.out.println("自定义Exception");
           }
       }
   }