黑马程序员---java学习笔记之面向对象知识点2

------- android培训、java培训、期待与您交流！ ----------

1、关于主函数

a）：main不是关键字，但是是特殊的单词，可以被jvm识别；

b）：某个类中可以存在main的重载函数，比如说public static void main(int x)等等，但是jvm只能识别一种形式(public static void main(String[] args))，作为程序的入口；

c）：主函数中参数变量名args是可以改变的,比如说public static void main(String[] a)也是可以的；

d）：可以向主函数传递参数的，如果没有传入，虚拟机默认传给main函数的参数时 new String[0]，传递参数在dos窗口下以及myeclipse下都可以设置；

e）：主函数可以被调用，示例如下：

public class MainTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
String[] arr = {"hello","hi","good","bad"};
MainTest2.main(arr);
}

}
class MainTest2
{
public static void main(String[] args)
{
for( int i = 0; i < args.length; i++ )
System.out.println(args[i]);
}
}

运行结果如下：



2、什么时候使用静态成员？

静态变量，当对象遇到共享数据时，该数据的属性应设置为静态的；

静态函数，当类中的某方法并没有访问到该类中的非静态成员时，该函数应定义成静态的。

3、静态的应用----工具类

工具类，没有该类对象的特有数据可操作，为了调用简单，将该类中所有函数设置为静态可访问的，并将其构造函数设置为private的。

4、默认构造函数的小知识点：

默认构造函数的权限修饰符与其类相一致。

5、下面是我模仿视频中的代码做的一个java api文档

/**
* 这是一个处理数组的工具类，功能主要有获取最值，排序，打印输出等
* @author 张三
* @version 1.0
*/
public class ArrayTool
{
/**
* 私有化的空参数构造函数
*/
private ArrayTool()
{
}

/**
* 获取数组中元素的最大值
* @param arr 传入一个int型数组
* @return 返回一个最大的元素值
*/
public static int getMax(int[] arr)
{
int max = arr[0];
for( int i = 1; i < arr.length; i++ )
if( max < arr[i] )
max = arr[i];
return max;
}
/**
* 获取数组中元素的最大值
* @param arr 传入一个int型数组
* @return 返回一个最大的元素值
*/

public static int getMin(int[] arr)
{
int min = arr[0];
for( int i = 1; i < arr.length; i++ )
if( min > arr[i] )
min = arr[i];
return min;
}

/**
* 对数组进行选择排序
* @param arr 传入一个int型数组
*/
public static void selectSort(int[] arr)
{
for( int i = 0; i < arr.length; i++ )
for( int j = i + 1; j < arr.length; j++ )
if( arr[i] > arr[j] )
swap(arr,i,j);
}
/**
* 对数组进行冒泡排序
* @param arr 传入一个int型数组
*/
public static void bubbleSort(int[] arr)
{
for( int i = 0; i < arr.length-1; i++ )
for( int j = 0; j < arr.length-1-i; j++ )
if( arr[j] > arr[j+1] )
swap(arr,j,j+1);
}
/**
*交换数组中的两个元素
@param arr 传入一个int型的数组
@param 元素1的下标
@param 元素2的下标
*/
private static void swap(int[] arr, int i, int j)
{
arr[i] = arr[i]^arr[j];
arr[j] = arr[i]^arr[j];
arr[i] = arr[i]^arr[j];
}
/**
* 打印输出数组的所有元素，打印的格式为[element1,element2,elenmet3,element4……].
* @param arr 传入一个int型数组
*/
public static void printArray(int[] arr)
{
System.out.print("["+arr[0]);
for( int i = 1; i < arr.length; i++ )
if( i != arr.length-1 )
System.out.print(","+arr[i]);
else
System.out.println("]");

}
/*public static void main(String[] args)
{
int[] arr = {75,59,68,25,64,113,103,97};
System.out.println(getMax(arr));
System.out.println(getMin(arr));
//selectSort(arr);
bubbleSort(arr);
printArray(arr);

}*/
}

6、静态代码块

a）：随着类的加载而加载，只执行一次，下面是示例：

class StaticCode{
static
{
System.out.println("abc");
}
}

public class StaticDemo {

public static void main(String[] args) {
// TODO Auto-generated method stub
new StaticCode();
new StaticCode();

}

}

运行结果只有一个“abc”

虽然在主函数里面创建了两个StaticCode的对象，但是输出时只有一个“abc”输出，也就是说某个类加载时执行一次静态代码块，加载之后再用这个类创建对象时就不在执行静态代码块了，这就是说“静态代码块随着类的加载而加载，并且只执行一次”。

b）：如果一个函数中含有静态代码块和主函数，运行时，静态代码块优先于主函数执行

public class StaticDemo {

static
{
System.out.println("a");
}

public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("c");

}
static
{
System.out.println("b");
}

}

运行的结果是：



由此可知静态代码块优先于主函数执行。

c）：静态代码块给类作初始化，构造代码块给该类的所有对象初始化，构造函数给相应的对象作初始化

7、什么时候才把一个类加载进内存呢？

当调用到某类的成员时，就会把该类加载进内存。比如说，new一个该类的对象时，因为要调用该类的某一个构造函数，所以会把该函数加载进内存；在比如说，调用该类的某个静态方法时，也会将该类加载进内存。另外需要注意的是，只声明某一个类的引用，java虚拟机是不会把该类加载进内存的。示例如下：

class StaticCode{
static
{
System.out.println("abc");
}
}
public class StaticDemo {

public static void main(String[] args){
StaticCode s = null;

}

}

这是没有运行结果的！因为只是声明某类的引用，而没有具体调用该类的成员，所以静态代码块是不会执行的！

8、对象初始化过程

结合一个具体的代码来说明这个过程，以下是代码：

public class Person {

private int age;
private String name;
static String nationality = "cn";

static
{
show();
}

public static void show()
{
System.out.println(nationality);
}

{
System.out.println("a");
}

public Person(int age)
{
this.age = age;
}

public Person(int age,String name)
{
this.age = age;
this.name = name;
System.out.println("age = "+age+",name = "+name);
}

public static void main(String[] args) {

Person p2 = new Person(16,"zhangsan");
}

}

运行结果为：



a）：将java源程序编译出.class文件，当运行该.class文件时，系统会产生一个java进程，并且为该进程分配了内存空间(即堆、栈、方法区、本地方法区等)，然后该文件被java虚拟机加载进分配的方法区内存；

b）：随着该类的加载，该类中的静态成员 (静态属性nationality和静态方法show) 就可以被访问，静态代码块就会执行，所以“cn”最先被输出；

c）：接着，java虚拟机就会找到该类的主函数(找不到就报错！注意，一个没有主函数的类是可以编译通过的，但是该类运行时就会报错！)，然后开始执行主函数的语句；

d）：当读到创建对象那行代码"Person p2 = new Person(16,"zhangsan");",java虚拟机就会在栈中为Person型的引用p2开辟内存空间，然后在堆中创建对象实体；

e）：对堆中对象实体的非静态变量进行默认初始化；

f）：对堆中对象实体的非静态变量进行显式初始化；

g）：然后一次执行构造代码块和构造函数对该对象进行进一步的初始化，所以一次会输出“a”、“age = 16,name = zhangsan”；

h）：将该对象的地址复制给引用p2.

9、单例设计模式

单例设计模式三要素的代码体现：

private static Single s = new Single();

private Single()
{}

public static Single getInstance()
{
return s;
}

静态且私有的唯一实例s，私有化的构造函数，以及静态公有的获取单例引用的函数，上述为饿汉式的单例设计模式

还有一种是懒汉式的单例设计模式：

private static Single s = null;

private Single()
{}

public static Single getInstance()
{
if( s == null )
s = new Single();
return s;
}

懒汉式的单例设计模式是有安全隐患的，所以一般开发用的是饿汉式的单例设计模式。懒汉式的安全隐患是，在多个线程同时调用getInstance时，容易出现！