01-面向对象(Static关键字)

1 package myFirstCode; 2  3 /* 4 静态：static。 5 用法：是一个修饰符，用于修饰成员（成员变量，成员函数） 6 当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外， 7 还可以直接被类名调用。类名.静态成员。 8  9 static特点：10 1，随着类的加载二加载。11 2，优先于的对象存在12 3，被所有对象所共享13 4，可以直接被类名所调用14 15 实例变量和类变量的区别：16 1，存放位置。17     类变量随着类的加载而存在于方法区中。18     实例变量随着对象的建立而存在于堆内存中。19 2，生命周期：20     类变量生命周期最长，随着类的消失而消失。21     实例变量生命周期随着对象的消失而消失。22     23 静态有利有弊：24 利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。25     可以直接被类名调用。26 弊端：生命周期过长。27     访问出现局限性。（静态虽好，只能访问静态）28     29 */30 31 class StaticDemo {32 33     class Person34     {35         String name;//成员变量，实例变量。36         static String country = "CN";//静态的成员变量，类变量。37         public static void show()38         {39             System.out.println("::::");40             this.haha();41         }42         public void haha()43         {}44     }45     public static void main(String[] args) {46         // TODO Auto-generated method stub47         Person.show();48     }49 50 }

02-面向对象(main函数)

1 package myFirstCode; 2  3 /* 4 public static void main(String[] args) 5  6 主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。 7  8 主函数的定义： 9 public：代表着该函数访问权限是最大的。10 static：代表主函数随着类的加载就已经存在了。11 void：主函数没有具体的返回值。12 main：不是关键字，但是是一个特殊的单词，可以被jvm识别。13 (String[] arr):函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。14 15 主函数是固定格式的：jvm识别。16 17 jvm在调用主函数时，传入的是new String[0];18 */19 20 class MainDemo {21 22     public static void main(String[] args) {23         // TODO Auto-generated method stub24         String[] arr = {"haha","hehe","heihei"};25         MainTest.main(arr);26     }27 28     29 static class MainTest30 {31     public static void main(String[] args) {32         for (int x = 0; x < args.length; x++) {33             System.out.println(args[x]);34         }35     }36 }37 }

03-面向对象(静态什么时候使用)

1 package myFirstCode; 2  3 /* 4 什么时候使用静态？ 5 要从两方面下手： 6 因为静态修饰的内容有成员变量和函数。 7 什么时候定义静态变量（类变量）呢？ 8 当对象中出现共享数据时，该数据被静态所修饰。 9 对象中的特有数据要定义成非静态存在于堆内存中。10 11 什么时候定义静态函数呢？12 当功能内部没有访问到非静态数据（对象的特有数据），13 那么该功能可以定义成静态的。14  */15 16 public class Person1 {17     18     19         String name;20         public static void show()21         {22             System.out.println("haha");23         }24     25 }26 class Person2{27     public static void main(String[] args) 28     {29         //Person p = new Person();30         //p.show();31         Person1.show();32 33     }34 35 }

04-面向对象(静态的应用-工具类)

1 package myFirstCode; 2  3 /* 4 静态的应用。 5 每一个应用程序中都有共性的功能。 6 可以将这些功能进行抽取，独立封装。 7 以便复用。 8  9 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。10 发现了问题：11 1. 对象是用于封装数据的，可是ArrayTool对象并未封装特有数据；12 2. 操作数组的每一个方法都没有用到ArrayTool对象中的特有数据；13 14 这时就考虑，让程序更严谨，是不需要对象的。15 可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。16 17 将方法都静态后，可以方便用于使用，但是该类还是可以被其他程序建立对象的。18 为了更为严谨，强制让该类不能简历对象。19 可以通过将构造函数私有化完成。20 21 private ArrayTool（）  --  私有化22 */23 24 class ArrayTool25 {26     private ArrayTool(){};  //私有化27     public static int getMax(int[] arr)28     {29         int max = 0;30         for (int x = 1; x < arr.length; x++) 31         {32             if (arr[x]>arr[max])33                 max =x ;        34         }35         return arr[max];36     }37     public static int getMin(int[] arr)38     {39         int min = 0;40         for (int x = 1; x < arr.length; x++) 41         {42             if (arr[x]

1 package myFirstCode; 2  3 class ArryToolDemo 4 {     5     public static void main(String[] args) { 6  7         int[] arr = {3,6,98,65,5}; 8 //        ArrayTool tool = new ArrayTool(); 9         10         11         int max = ArrayTool.getMax(arr);12         System.out.println("Max = " + max);13     }14 15 }

05-面向对象(帮助文档的制作javadoc)

1 package myFirstCode;  2   3 /*  4 静态的应用。  5 每一个应用程序中都有共性的功能。  6 可以将这些功能进行抽取，独立封装。  7 以便复用。  8   9 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。 10 发现了问题： 11 1. 对象是用于封装数据的，可是ArrayTool对象并未封装特有数据； 12 2. 操作数组的每一个方法都没有用到ArrayTool对象中的特有数据； 13  14 这时就考虑，让程序更严谨，是不需要对象的。 15 可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。 16  17 将方法都静态后，可以方便用于使用，但是该类还是可以被其他程序建立对象的。 18 为了更为严谨，强制让该类不能简历对象。 19 可以通过将构造函数私有化完成。 20  21 private ArrayTool（）  --  私有化 22 */ 23  24 /* 25 这是一个可以对数组进行操作的工具类，该类中提供了，获取最值等功能。 26 @author xuliang 27 @version V1.1 28 */ 29 class ArrayTool 30 { 31      32     /* 33     空参数构造函数。 34      */ 35     private ArrayTool(){};  //私有化 36      37     /* 38     获取一个整型数组中的最大值。 39     @param arr 接收一个int类型的数组。 40     @return 会返回一个该数组中的最大值。 41      */ 42     public static int getMax(int[] arr) 43     { 44         int max = 0; 45         for (int x = 1; x < arr.length; x++)  46         { 47             if (arr[x]>arr[max]) 48                 max =x ;         49         } 50         return arr[max]; 51     } 52      53     /* 54     获取一个整型数组中的最小值。 55     @param arr 接收一个int类型的数组。 56     @return 会返回一个该数组中的最小值。 57      */ 58     public static int getMin(int[] arr) 59     { 60         int min = 0; 61         for (int x = 1; x < arr.length; x++)  62         { 63             if (arr[x]
      
       arr[y]) 81                 { 82                     swap(arr,x,y); 83                      84                 } 85                  86             } 87              88         } 89     } 90  91      92     /* 93     给数组中元素进行位置的置换。 94     @param arr 接收一个int类型的数组。 95     @param a 要置换的位置 96     @param b 要置换的位置 97      */ 98     private void swap(int[] arr, int a , int b)  99     {100         int temp = arr[a];101         arr[a] = arr[b];102         arr[b] = temp;103         104     }105     106 }107 108 /*109 一个类中默认会有一个空参数的构造函数，110 这个默认的构造函数的权限所属类一致。111 如果类被public修饰，那么默认的构造函数也带public修饰符。112 如果类没有被public修饰，那么默认的构造函数，也没有public修饰。113  */
      

06-面向对象(静态代码块)

1 package myFirstCode; 2  3 /* 4 静态代码块 5 格式： 6 static 7 { 8     静态代码块中的执行语句。 9 }10 11 特点：随着类的加载而执行，只执行一次，并优先于主函数。12 用于给类进行初始化的。13 */14 15 16 class StaticCode17 {18     static19     {20         System.out.println("a");21     }22 }23 24 public class StaticCodeDemo 25 {26     static27     {28         System.out.println("b");29     }30 31     public static void main(String[] args) 32     {33         new StaticCode();34         new StaticCode();35         System.out.println("over");36         37 38     }39     static40     {41         System.out.println("c");42     }43 44 }

07-面向对象(对象的初始化过程)

1 package myFirstCode; 2  3  4 class Person 5 { 6     private String name; 7     private int age; 8     Person(String name,int age) 9     {10         this.name = name;11         this.age = age;12     }13     public void setAge(int a)14     {15         if(a>0 && a<130)16         {17             age = a;18             speak();19         }20         else21             System.out.println("false age");22     }23     24     public int getAge()25     {26         return age;27     }28     29     30     void speak()31     {32         System.out.println("age = "+age);33     }34 }35 36 37 //public class personDemo {38 //39 //    public static void main(String[] args) {40 //        // TODO Auto-generated method stub41 //        Person p = new Person();42 //        p.setAge(25);43 //    }44 //45 //}46 47 48 public class personDemo {49 50     public static void main(String[] args) {51         // TODO Auto-generated method stub52         Person p = new Person("zhangsan",20);53     }54 55 }56 57 58 /*59 Person p = new Person("zhangsan",20);60 61 该句话都做了什么事情？62 1. 因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。63 2. 执行该类中的static代码块，如果有的话，给person.class类进行初始化。64 3. 在堆内存中开辟空间，分配内存地址。65 4. 在堆内存中简历对象的特有属性。并进行默认初始化。66 5. 对属性进行显示初始化。67 6. 对对象进行构造代码块初始化。68 7. 对对象进行对应的构造函数初始化。69 8. 将内存地址付给栈内存中的p变量。70 71  */

08-面向对象(对象调用成员过程)

09-面向对象(单例设计模式)

1 package myFirstCode; 2  3 /* 4 设计模式：解决某一类问题最行之有效的方法。 5 Java中23种设计模式： 6 单例设计模式：解决一个类在内存只存在一个对象。 7  8 想要保证对象唯一。 9 1. 为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。10 2. 还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。11 3. 为了方便其他程序对自定义的访问，可以对外提供一些访问方式。12 13 这三步怎么用代码体现呢？14 1. 将构造函数私有化15 2. 在类中创建一个本类对象。16 3. 提供一个方法可以获取到该对象。17 18 19 对于事物该怎么描述，还怎么描述。20 当需要将该事物的对象保证在内存中唯一时，就将以上的三步加上即可。21 22  */23 24 class Single25 {26     private Single(){}27     private static Single s = new Single();28     public static Single getInstance()29     {30         return s;31     }32     33 }34 35 public class SingleDemo {36 37 38     public static void main(String[] args) 39     {40 //        Single ss = Single.getInstance();41 42     }43 44 }45 46 class Student47 {48     private int age;49     50     private static Student s = new Student();51     private Student(){};52     public static Student getStudent()53     {54         return s;55     }56     57     public void setAge(int age)58     {59         this.age = age;60         61     }62     public int getAge()63     {64         return age;65     }66 }

10-面向对象(单例设计模式方式二)

1 package myFirstCode; 2  3  4 /* 5 这个是先初始化对象。 6 称为：饿汉式。 7  8 //class Single 9 //{10 //    private static Single s  =  new Single();11 //    private Single(){};12 //    public static Single getInstance()13 //    {14 //        return s;15 //    }16 //}17 */18 19 //对象是方法被调用时，才初始化，也叫作对象的延时加载。称为：懒汉式。**不常用，面试时候用20 class Single21 {22     private static Single s = null;23     private Single(){};24     public static Single getInstance()25     {26         if (s==null)27             s = new Single();28         return s ;29     }30 }31 32 33 34 public class SingleDemo2 {35 36     public static void main(String[] args) {37         // TODO Auto-generated method stub38 39     }40 41 }