Java基础笔记-面向对象2

构造函数:(当类中没有定义构造函数时,系统会默认给该类加入一个空参数的构造函数)

格式:

class Person

{

　　Person(){} //空参数

}

1.函数名与类名相同,

2,不定义返回值类型,即不能写return语句.

作用:给对象进行初始化.

与一般函数的区别:

1.构造函数 只执行一次,其他函数可以被执行多次.

 

构造代码块:

构造代码块,给对象进行初始化,对象一建立就运行,且优先于构造函数

与构造函数的区别:

相同点是,都是给对象进行初始化使用的.

构造代码块是给所有对象进行初始化的,而构造函数是给对应的对象进行初始化.

构造代码块中定义的是不同对象的共性的初始化内容.
格式:

例如:
 {
  System.out.println("构造代码块!");
 }

 

 

this关键字:

作用:用于区别成员变量与局部变量 同名的情况.

例如:

class Person{

String name; //--->成员变量name.

Person(String name) //--->局部变量ame.

{

　　this.name=name;  // this.name  ===>中的name指的就是成员变量的name.

　　name = name; //如果这样定义,这两个name都是局部变量name.

}

}

this代表它所在类的所属对象的引用,

通俗来讲:即哪个函数调用this所在的函数,this就代表哪个对象.

 

有关this关键字,构造函数和构造代码块的相关代码演示.

 1 class Person

 2 {

 3     private int age;

 4     private String name ;

 5     /*

 6     构造代码块,给对象进行初始化,对象一建立就运行,且优先于构造函数.

 7     与构造函数的区别:构造代码块是给所有对象进行初始化的,而构造函数是给对应的对象进行初始化.

 8     构造代码块中定义的是不同对象的共性的初始化内容.

 9     */

10     {

11         System.out.println("构造代码块!");

12         cry();

13     }

14     //构造函数

15     Person()

16     {

17         System.out.println("A: name = "+name+"    age = "+age);

18         //cry();

19     }

20     /*this: 关键字

21     作用:用于区别成员变量与局部变量同名的情况.

22     this代表它所在类的所属对象的引用,即哪个函数调用this所在的函数,this就代表哪个对象.

23     */

24     Person(int age)

25     {

26         this.age = age;

27         System.out.println("B: name = "+name+"    age = "+age);

28         //cry();

29     }

30     Person(int age ,String name)

31     {

32         this.age = age;

33         this.name = name;

34         System.out.println("C: name = "+this.name+"    age = "+this.age);

35         //cry();

36     }

37     

38     /*

39     this的应用:定义一个函数,比较两个人年龄是否相同.

40     */

41     public boolean compare(Person p)

42     {    

43         return this.age == p.age;  //this.age中的this代表的是调用这个函数的对象. ===>77行中的对象p4调用了compare函数,this就是代表的p4.

44     }

45     

46     //设置名字的函数

47     public void setName(String name)

48     {

49         this.name = name;

50     }

51     //获取名字的函数

52     public String getName()

53     {

54         return name;

55     }

56     

57     public void cry()

58     {

59         System.out.println("Cry--------!");

60     }

61 }

62 

63 class PersonDemo2

64 {

65     public static void main(String args [])

66     {

67         Person p1 = new Person();

68         Person p2 = new Person(10);

69         Person p3 = new Person(5,"Tom");

70         System.out.println(p3.getName());

71         

72         p3.setName("Paul");

73         System.out.println(p3.getName());

74         

75         Person p4 = new Person(25);

76         Person p5 = new Person(20);

77         boolean b = p4.compare(p5);  

78         System.out.println(b);

79 

80     }

81 }

 

static关键字:

用于修饰成员变量(全局变量)和函数.

被static修饰的变量，叫类变量,也叫做静态变量.

static成员变量只初使化一次，防止在其他文件单元中再被引用.

 

static局部变量和普通局部变量的区别:

1.把局部变量改变为静态变量后,改变了它的存储方式即改变了它的生存期.

2.把成员变量改变为静态变量后,改变了它的作用域，限制了它的使用范围.

static局部变量只被初始化一次，下一次依据上一次结果值； 　 

<什么时候定义静态函数:当功能内部没有访问到静态数据(对象的特有数据)时,该函数可以定义为静态函数.>???

 

由于静态函数在内存中只有一个实例,在使用过程中不需要再new实例化对象.这些类一般都是无状态的，函数谁调用都是一样的.

因此它们适用于工具类中.

工具类应用的有关代码练习操作:

  1 /**

  2 这是一个可以对数组进行操作的工具类,可以获取最值,排序,打印等功能.

  3 @author JerryHo

  4 @version V1.0

  5 */

  6 //要生成帮助文档,这个类必须是public的.

  7 public class ArrayTool

  8 {

  9     //将构造函数私有化以后,可以强制该类不能建立对象

 10     /**

 11     空参数构造函数.

 12     */

 13     private ArrayTool()

 14     {

 15         //系统会有个默认的构造函数

 16     }

 17     /**

 18     获取整型数组中的最大值.

 19     @param arr 接收一个int类型的数组.

 20     @return 返回该数组中的一个最大值.

 21     */    

 22     public static int getMax(int arr[])

 23     {

 24         int max=0;

 25         for(int x=0; x<arr.length;x++)

 26         if(arr[max]<arr[x])

 27         {

 28             max = x;

 29         }

 30         return arr[max];

 31     }

 32     /**

 33     获取整型数组中的最小值.

 34     @param arr 接收一个int类型数组.

 35     @return 返回该数组中的一个最小值.

 36     */

 37     public static int getMin(int arr[])

 38     {

 39         int min=0;

 40         for(int x=0;x<arr.length;x++)

 41         {

 42             if(arr[min]>arr[x])

 43             {

 44                 min = x;

 45             }

 46         }

 47         return arr[min];

 48     }

 49     /**

 50     对int类型的数组进行选择排序.

 51     @param arr 接收一个int类型数组.

 52     */

 53     public static void selectSort(int arr[])

 54     {

 55         for(int x =0;x<arr.length-1;x++)

 56         {

 57             for(int y=x+1;y<arr.length;y++)

 58             {

 59                 if(arr[x]>arr[y])

 60                 {

 61                     //int temp =arr[x];

 62                     //arr[x]=arr[y];

 63                     //arr[y]=temp;

 64                     swap(arr,x,y);

 65                 }

 66             }

 67         }

 68     }

 69     /**

 70     对数组进行冒泡排序.

 71     @param arr 接收一个int类型数组.

 72     */

 73     public static void  bubbleSort(int arr[])

 74     {

 75         for(int x=0;x<arr.length-1;x++)

 76         {

 77             for(int y =0;y<arr.length-1-x;y++)

 78                 if(arr[y]>arr[y+1])

 79                 {

 80                     //int temp =arr[y];

 81                     //arr[y]=arr[y+1];

 82                     //arr[y+1]=temp;

 83                     swap(arr,y,y+1);

 84                 }

 85         }

 86     }

 87     /**

 88     交换整型数组中的两个变量的值.

 89     @param arr 接收一个int类型数组.

 90     @param a 要置换的位置.

 91     @param b 要置换的位置.

 92     */

 93     private static void swap(int[]arr,int x,int y)

 94     {

 95         int temp =arr[x];

 96         arr[x]=arr[y];

 97         arr[y]=temp;

 98     }

 99     

100     /**

101     打印整型数组中的元素.

102     @param arr 接收一个int类型数组.

103     打印形式为:[element1,element2,...]

104     */

105     public static void printArray(int arr[])

106     {    

107         System.out.print("[");

108         for(int x=0;x<arr.length;x++)

109         {

110             if(x!=arr.length-1)

111             {

112                 System.out.print(arr[x]+",");

113             }

114             else

115             {

116                 System.out.println(arr[x]+"]");

117             }

118         }

119     }

120 }

 1 class ArrayToolDemo

 2 {

 3     public static void main(String args[])

 4     {

 5         /*

 6         int [] arr= new int[]{3,5,1,8,4,9,12};

 7         int [] arr1 = new int[]{9,3,6,18,13,4,23};

 8         ArrayTool at = new ArrayTool();

 9         

10         int max = at.getMax(arr);

11         System.out.println("max = "+max);

12         

13         int min =at.getMin(arr);

14         System.out.println("min = "+min);

15         

16         at.printArray(arr);

17         at.selectSort(arr);

18         at.printArray(arr);

19         

20         at.printArray(arr1);

21         at.bubbleSort(arr1);

22         at.printArray(arr1);

23         */

24         

25         //直接用类名调用有关的函数.

26         int [] arr= new int[]{3,5,1,8,4,9,12};

27         int [] arr1 = new int[]{9,3,6,18,13,4,23};

28         

29         int max = ArrayTool.getMax(arr);

30         System.out.println("max = "+max);

31         int min = ArrayTool.getMin(arr);

32         System.out.println("min = "+min);

33         

34         int Max = ArrayTool.getMax(arr1);

35         System.out.println("max = "+Max);

36         int Min = ArrayTool.getMin(arr1);

37         System.out.println("min = "+Min);

38         

39         ArrayTool.printArray(arr);

40         ArrayTool.selectSort(arr);

41         ArrayTool.printArray(arr);

42         

43         ArrayTool.printArray(arr1);

44         ArrayTool.selectSort(arr1);

45         ArrayTool.printArray(arr1);

46         

47         

48     }

49 }

 

昨天停了快一天的电,一晚上热的没睡好,早上起来就开始看,看完教程还得自己思考,好多地方不是很懂不过还是慢慢来把,感觉脑袋都有些僵硬了,看完视频教程都快11点多了,又得做笔记,还得想想总结一天学的东西,然后敲代码,编译以后发现总是好多问题,又改来改去的看问题出现在哪里,一折腾就11点快12点了,在还得写博客记录,一天下来感觉又充实又累人,有种高三的感觉啊,洗澡睡觉去,明天还得继续..hold on...!