潭州Java中级班（day_10）-静态代码块，构造代码块，单例设计模式，重写，多态

Day09面向对象（三）

1. 静态代码块

* 静态代码块格式：

* static{

* }

* 特点：

* 1.创建对象的时候会调用静态代码块。

* 2.静态代码块只执行一次。

* 3.静态代码块>构造代码块>构造函数。

/**
 * 这个类是讲述静态代码块
 * @ClassName:     Demo1Static.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月29日   下午7:24:09 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * 静态代码块格式：
 *         static{
 *         
 *         }
 * 特点：
 *     1.创建对象的时候会调用静态代码块。
 *     2.静态代码块只执行一次。
 *     3.静态代码块>构造代码块>构造函数。
 */
class  User{
       static   {
             System.out.println("1.开东风悦达起亚");
       }
       static   {
             System.out.println("2.开宝马X6");
       }
       public   User(){
             System.out.println("3.开法拉利");
       }
}
public class Demo1Static {
       public static void main(String[] args) {
                 new    User();  //1   2   3
                 new    User();  //3
       }
}

2. 构造代码块

* 构造代码块：

* {

* }

* 特点：

* 1.执行构造函数的时候会调用构造代码块,也就说每调用一次构造函数，就执行一次构造代码块。

* 2.构造代码块优先于构造函数执行。

* 3.静态的是随着类的加载而加载，非静态成员是随着对象的加载而加载。

* 4.静态代码块优先于构造代码块。

/**
 * 这个类是讲述构造代码块
 * @ClassName:     Demo2Construtor.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月29日   下午7:26:05 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * 构造代码块：
 *        {
 *        
 *        }
 * 特点：
 *      1.执行构造函数的时候会调用构造代码块,也就说每调用一次构造函数，就执行一次构造代码块。
 *      2.构造代码块优先于构造函数执行。
 *      3.静态的是随着类的加载而加载，非静态成员是随着对象的加载而加载。
 *      4.静态代码块优先于构造代码块。
 */
class    User2{
        String   name;
        int       age;
        {
                System.out.println("1.开奥拓");
        }
        static{
                System.out.println("3.开拖拉机");//jdbc连接数据库，封装的时候
        }
        public   User2(){
                System.out.println("2.开QQ");
        }
}
public class Demo2Construtor {
        public static void main(String[] args) {
                  new   User2();  //3  1   2
                  new   User2();  //1  2
        }
}

3. 单例设计模式

* 单例：就是一个实例化，也就说只new了一次.也就是说一个对象被所有人共享。

* 饿汉式:

  private static   Person    person=new  Person();

 *          public  static      Person      getPerson(){

        return  person;

        }

* 懒汉式：

 private static   Person     person;

 *          public  static      Person      getPerson(){

        if(person==null){

             person=new  Person();

        }

        return  person;

        }

 *

* 封装：封装属性和实现细节，仅对外提供公共的方法进行访问。

* 封装构造函数：private

* 引用数据类型的默认值都是null

/**
 * 这个类是讲述单例设计模式
 * @ClassName:     Demo3Single.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月29日   下午7:26:58 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/* 
 * 
 * 单例：就是一个实例化，也就说只new了一次.也就是说一个对象被所有人共享。
 * 饿汉式:
 *          private static   Person    person=new  Person();
 *          public  static      Person      getPerson(){
                    return  person;
            }
 * 懒汉式：
 *             private static   Person     person;
 *          public  static      Person      getPerson(){
                    if(person==null){
                            person=new  Person(); 
                    }
                    return  person;
            }
 * 
 * 封装：封装属性和实现细节，仅对外提供公共的方法进行访问。
 * 封装构造函数：private  
 * 
 * 引用数据类型的默认值都是null
 * 
 * 
 * 封装构造函数，然后去调用该类中非静态方法？
 * class  Person{
       private   Person(){
       }
       private   String       name;  
       public     void    setName(String  nn){
                this.name=nn;
       }
   }
 */
class  Person{
       private   static  Person     pp=new  Person();//pp默认是等于null  pp=new  Person()；
       private   Person(){
       }
       public  static Person  getInstance(){
                return  pp;
       }
       
//       public  static      Person      getInstance(){
//                if(pp==null){   //pn进来，是第一次，pp是null;
//                                //第二次就不是null，有值
//                    pp=new  Person(); 
//                }
//                return  pp;
//       }
       
}
public class Demo3Single {
       public static void main(String[] args) {
               Person    pn=Person.getInstance();//pn=pp
               
               Person    pn2=Person.getInstance();//pn2=pp
               
               System.out.println(pn==pn2);
               
               
               
//               String  str2=pn2.getName();
//               System.out.println("str2="+str2);
//               
//               
//               pn.setName("潽");
//               String  str=pn.getName();
//               System.out.println("str="+str);
    }
}
/*
 
 class  Person{
       private static   Person     pp;//
       private   Person(){
       }
       public  static      Person      getInstance(){
                if(pp==null){
                    pp=new  Person(); 
                }
                return  pp;
       }
       
       private   String       name;  //私有成员变量，
       //this:。。。的意思   哪个对象调用就指哪个对象。this只能调用成员变量
       public   void    setName(String  nn){//String  name="南浔"
                this.name=nn;
       }
       public    String    getName(){
                return  name;
       }
}
 
 
 */

问题：

* 封装构造函数，然后去调用该类中非静态方法？

* class  Servlet1{

   private   Servlet1(){

   }

   private   String       name;  

   public     void    setName(String  nn){

        this.name=nn;

   }

   }

4. 重写

* 重载：方法名相同，参数类型或者参数个数不同。

* 重写：也叫复写，覆盖

* 子类方法跟父类方法相同。除了访问权限修饰符必须大于等于父类访问权限，其他都必须一直。

* 注意：私有的不能被重写。

/**
 * 这个类是讲述重写
 * @ClassName:     Demo4Override.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月29日   下午7:27:48 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/* 
 * 重载：  方法名相同，参数类型或者参数个数不同。
 * 
 * 重写：  也叫 复写，覆盖
 *      子类方法跟父类方法相同。除了访问权限修饰符必须大于等于父类访问权限，其他都必须一直。
 *      注意：私有的不能被重写。
 */
class   Fu{
       String  car="宝马";
       protected   void    play(){
               System.out.println("玩麻将!");
       }
}
class   Zi  extends  Fu{
       String  car="奔驰";
       public   void    play(){
               System.out.println("玩Java!");
       }
}
public class Demo4Override {
       public static void main(String[] args) {
              Zi   zi=new  Zi();
              zi.play();
    }
}

5. 多态

* 多态：事物的多种存在形态。

* 体现：父类引用指向子类对象。

* 格式：

* 父类对象名=new 子类();

* 多态的特点：

* 1.访问非静态成员变量：编译看父类运行看父类

* 2.访问静态成员变量：编译看父类运行看父类

* 3.访问非静态成员函数：编译看父类运行看儿子

* 4.访问静态成员函数：编译看父类运行看父类

/**
 * 这个类是讲述多态英poli'mo:fizəm
 * @ClassName:     Demo5Polymorphism.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月29日   下午7:47:40 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * 多态：  事物的多种存在形态。
 * 体现：  父类引用指向子类对象。
 * 格式：
 *      父类        对象名=new    子类();
 *      
 *      
 * 多态的特点：
 *     1.访问非静态成员变量： 编译看父类                运行看父类
 *     2.访问静态成员变量：    编译看父类                运行看父类
 *     3.访问非静态成员函数： 编译看父类                运行看儿子
 *     4.访问静态成员函数：    编译看父类                运行看父类
 *     
 * 
 * 总结：多态编译都看父类，运行也看父类（除了非静态成员函数）。
 *     
 */
class   Animal{
        double    weight=50;
        static   String    name="无名";
        public   void   play(){
                System.out.println("玩爬树");
        }
        public  static  void   eat(){
            System.out.println("动物吃空气");
        }
}
class   Cat   extends   Animal{
        double    weight=10;
        static   String    name="猫";
        public   void   play(){
            System.out.println("猫玩老鼠");
        }
        public  static  void   eat(){
            System.out.println("猫吃鱼");
        }
}
public class Demo5Polymorphism {
         public static void main(String[] args) {
                //父类               引用    指向         子类对象
                Animal     animal =      new   Cat();//多态：
                animal.play();
                animal.eat();
                
                
                
                
                
                
                
                double   weight=animal.weight;
                System.out.println("weight="+weight);
                
                String    name=animal.name;
                System.out.println("name="+name);
                
                
        }
}

应用：

/**
 * 这个类是讲述多态的运用
 * @ClassName:     Demo51PolymorphismApply.java
 * @Description:   TODO  
 * @author         Jim老师 
 * @version        jdk8.0  
 * @Date           2018年8月29日   下午10:29:42 
                     无敌是多么的寂寞
                     男人不能说不行，不行也得行
 */
/*
 * 喂养动物的例子
 *  
 */
class   Cat5   extends    Animal5{
        
}
public class Demo51PolymorphismApply {
          public static void main(String[] args) {
                     Animal5   aa=new    Cat5();//多态
                     feed(aa);
          }
          public   static   void   feed(Animal5   animal5){ //Animal5  animal5=?;aa;
                     animal5.eat();
          }
}
abstract   class   Animal5{   //这是抽象类，抽象类不能new对象
        public   void  eat(){
                System.out.println("动物吃");
        }
}

* 总结：多态编译都看父类，运行也看父类（除了非静态成员函数）。