“黑马程序员”学习笔记五

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

 /**
 同一个类中的成员函数可以相互调用，方法前面省略的是“类名.”因为在同一个类中不用写
 记住静态中不能使用this和super
 为什么要使用单例设计模式？
 是为了在内存中保证该对象的唯一性，多次调用的初始状态始终为前一次调用后的结果。
 单例的设计模式思想：
  1.将构造函数私有化，以防止此类被建立对象调用
  2.建立一个静态并私有的本类对象
  3.建立一个公有并静态的方法以调用该类
  */
  class Single_1
 {
  private static Single_1 s=new Single_1();
  private Single_1(){}
  public static Single_1 getInstance()
  {
   return s;
  }
  //饿汉式
 }
 
 class Single_2
   {
     private static Single_2 s=null;
   private Single_2(){}
   public static Single_2 getInstance()
   {
    if(s==null)
      {
     synchronized(Single_2.class)
     {
      if(s==null)
       s=new Single_2();
     }
      }
     return s;//懒汉式
     }
   }
 
public class MingTian1 {
 public static void main(String[] args) {
  //Single.getInstance();

 }

}/*子类继承父类覆盖父类功能时，子类的权限必须大于等于父类，否则编译失败
 静态只能覆盖静态
 注意：重写的两个方法包括返回值和函数名必须一模一样和重载时有区别的
*/

/*多态：
 * 1.多态的体现：父类应用指向了子类对象或接收了子类对象
 * 2.前提：必须是有关系的类之间，要么继承要么实现，并且还存在覆盖内容
 * 3.好处：提高了程序的扩展性
 * 4.弊端：虽然提高了扩展性但是只能使用父类的应用访问父类中的成员
 *重： 5.父类应用指向子类对象时，编译看的是父类方法，如果父类没有该对象要引用
 * 的方法则编译失败，有才能通过，运行时，如果父类有方法被子类覆盖，则运行
 * 的是子类方法，没有覆盖则运行的是子类继承父类的方法。
 * 简单说，就是编译看左边，运行看右边（对于变量，不管是编译还是运行都参考左边）
*/
abstract class Animal
{
 public abstract void eat();
}
class Cat extends Animal
{
 public void eat()
 {
  System.out.println("吃鱼");
 }
 public void catchMouse()
 {
  System.out.println("抓老鼠");
 }
}
class Dog extends Animal
{
 public void eat()
 {
  System.out.println("吃骨头");
 }
 public void kanJia()
 {
  System.out.println("看家");
 }
}
public class MingTian2
{
  public static void function(Animal a)
  {
   a.eat();
   if(a instanceof Cat)
   {
    Cat t=(Cat)a;
    t.catchMouse();
   }
   else if(a instanceof Dog)
   {
    Dog d=(Dog)a;
    d.kanJia();
   }
  }

 
 public static void main(String[] args)
 {
  function(new Cat());
  function(new Dog());
  /*Animal z=new Cat();//升级类型转换,为了增加扩展性
  z.eat();
  Cat t=(Cat)z;//降级类型转换，为了调用子类其他功能
  t.catchMouse();*/
 }

}

 /**
  接口的使用
  */
 interface PCI
 {
  public abstract void open();
  public abstract void close();
 }
 class MainBoard
 {
  public void run()
  {
   System.out.println("主板运行");
  }
  public void usePCI(PCI p)//建立一个接口型变量p，属于多态的使用
  {
   if(p!=null)
   {
    p.open();
    p.close();
   }
  }
 }
 class soundCard implements PCI
 {
  public void open()
  {
   System.out.println("声卡开启");
  }
  public void close()
  {
   System.out.println("声卡关闭");
  }
 }
 class netCard implements PCI
 {
  public void open()
  {
   System.out.println("网卡开启");
  }
  public void close()
  {
   System.out.println("网卡关闭");
  }
 }
 public class MingTian3
 {

  public static void main(String[] args)
  {
   MainBoard m=new MainBoard();
   m.run();
   m.usePCI(new soundCard());
   m.usePCI(null);
   m.usePCI(new netCard());
  }

 }

/*
 * 内部类和匿名内部类
 * 内部类可以直接访问外部类中的成员，包括私有
 *   之所以能访问是因为内部类中的应用前面有默认的“外部类名.this.”
 * 外部类要访问内部类必须建立对象
 * 当内部类在外部类成员位置时，前面可以使用成员修饰符（如：private,static）
 * 访问方式：
 * 1.当内部类在成员位置并且没有被private修饰时(记住：当内部类被静态修饰时只能
 * 访问外部类中的静态成员)
 *  Outer.Inner in=new Outer().new Inner();
 *    in.function();
 * 2.当内部类处于外部类的静态成员位置时(记住：内部类中的成员可以是非静态的)
 *  new Outer.Inner().function()
 * 注意：内部类中只要接触到了静态成员或方法就必须加静态,
 * 当外部类中的静态方法访问到内部类时，内部类需要加static修饰
 * 3.访问静态内部类中的静态方法
 *  Outer.Inner.function();
 * 注意：局部内部类可以正常访问本类变量，但是无法访问成员函数中的变量，如果要访问，
 * 则必须在在该变量前加final修饰
 * 匿名内部类：
 * 1.匿名内部类定义的前提是该内部类必须继承一个类或者实现了接口 
 * 2.匿名内部类需要实现的功能：1.建立父类对象，复写父类方法；2.调用该方法
 * 如：new 父类类名（）{复写父类function()}.function();
 * 3.匿名内部类只能复写父类方法，而不能增加任何方法，而且复写的方法最多只能
 * 2个，多了没有阅读性
 * */

 class Outer
 {
  int x=4;
  public void function(final int y)//因为局部内部类访问到y所以该变量前需加final修饰
  {
   class Inner
/*这个内部类如果不在function()中建立对象的话是无法运行的也就是说内部
 * 类在局部位置时，必须在该局部中建立自己的对象，否则无法运行*/
   {
    void show()
    {
     System.out.println(Outer.this.x);
     System.out.println(y);
    }
   }
   new Inner().show();
  }
 }
public class MingTian4
{
 public static void main(String[] args)
 {
  Outer o=new Outer();
  o.function(7);
  o.function(10);
 }

}

/*异常：是程序运行（编译时可以通过）时出现不正常情况
 * 异常的由来：异常也是现实生活中的一个具体事物也可以通过java的类的形式
 * 进行描述并封装成对象，其实就是java对不正常情况进行描述后的对象体现
 * 对于问题的划分：
 * Exception(异常，可以处理的问题，需编写代码进行处理);
 * Error（错误，不可以处理的问题，不编写代码进行处理）
 * Throwable是Exception和Error的父类
 * 异常处理的基本模式(没有返回值类型的方法，不用使用打印语句，可以自己打印)
 * 一个函数中只要出了一个异常后面的语句全都执行不到，无论throws与否(在
 * 语句中抛出用throw)
 * 在函数内thow,函数上必须用thows声明；而且thow抛出的必须是一个对象，
 * 如：thow new FuShuException();
 * throws可以抛出多个异常类，throw只能抛出一个对象
 * catch必须有针对性，throws什么异常就处理什么异常；如果多个catch异常
 * 中出现继承关系，父类catch块尽量往后放，在catch块中一定要有针对性的处理
 * 方式,不要简单的一句e.printStackTrace
 * try
 * {
 *   需要被检测的代码；
 * }
 * catch(异常类   变量)
 * {
 *   处理异常的代码；（处理方式）
 * }
 * finally
 * {
 *   一定会执行的语句；
 * }
 * */

/*异常练习，老师讲课的例子。
重点：每个函数只能声明自己的异常，对于它调用的对象的异常声明需进行try{}catch{}处理
子类继承父类，如果父类抛出了异常，那么子类只能抛出父类的异常或该异常的子类；
如果父类抛出多个异常，子类只能抛出这些异常的子类，如果子类出现新的异常，只能
try{}catch{}不能抛。
*/
 class Teacher
 {
   private String name;
   private computer com;
   Teacher(String name)
   {
    this.name=name;
    this.com=new computer();
   }
   public void speak() throws NoPlanException
   {
    try
    {
    com.run();
    }
    catch(LanPingException e)
    {
     System.out.println("电脑蓝屏了");
     com.reset();
    }
    catch(MaoYanException e)
    {
     throw new NoPlanException("课时无法继续"+e.toString());
    }
    System.out.println("开始上课");
   }
 }
 class computer
 {
  private int num=2;
  public void run() throws MaoYanException,LanPingException
  {
   if(num==2)
   throw new LanPingException("蓝屏了");
   if(num==3)
   throw new MaoYanException("冒烟了");
   if(num==1)
   System.out.println("电脑运行");
  }
  public void reset()
  {
   num=1;
   System.out.println("电脑重启");
  }
 }
 class MaoYanException extends Exception
 {
   MaoYanException(String message)
  {
   super(message);
  }
 }
 class LanPingException extends Exception
 {
  LanPingException(String message)
  {
   super(message);
  }
 }
 class NoPlanException extends Exception
 {
  NoPlanException(String message)
  {
   super(message);
  }
 }
 public class MingTian6
 {
  public static void main(String[] args)
  {
   Teacher t=new Teacher("毕老师");
   try
   {
    t.speak();
   }
   catch(NoPlanException e)
   {
    System.out.println("换老师");
    System.out.println(e.toString());
   }
  }

 }