一、构造函数和代码块
对象一建立就会调用与之对应的构造函数
构造函数的作用，可以用于给对象进行初始化。
构造函数的小细节:
当一个类中没有定义构造函数时。那么系统会默认给该类加入一个空参数的构 造函数
当在类中定义了构造函数后。默认的构造函数就没有了。
构造函数和一般函数在写法上有不同
在运行上也有不同。
构造函数是在对象以一建立就执行，给对象初始化。
而一般方法是对象调用才执行，是给对象添加对象具备的功能。
一个对象的建立，构造函数只运行一次。
而一般方法可以被该对象调用多次。
什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为。那么将这些内容定义在构造函数中。
构造代码快。作用：给对象进行初始化。
对象一建立就运行。而且优先于构造函数执行。
和构造函数的区别:
构造代码块是给所有对象进行统一初始化，
而构造函数是给对应的对象初始化。
构造代码块中定义的是不同对象共性的初始化内容。
二、多态
多态：可以理解为事物存在的多种体现形态
1，多态的体现
父类的引用指向了自己的子类对象
父类的引用也可以接受自己的子类对象。
2，多态的前提
必须是类与类之间有关系，要么继承，要么实现。
通常还有一个前提，存在覆盖。
3，多态的好处
多态的出现大大提高程序的扩展性。
4.多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员。
5，多态的应用
6，多态的出现代码中的特点（多态使用的注意事项）
在多态中成员函数的特点：
在编译时期：参阅引用变量（也就是父类)所属的类中是否有调用的 方法。如果有编译通过。如果没有编译失败。
在运行时期：参阅对象所属的类中是否有调用的方法。
简单总结就是编译时期看左边。运行时期看右边。
在多态中，成员变量的特点。
无论编译和运行。都参考左边（引用型变量（也就是父类)所属的 类);
在多态中，静态成员函数的特点；
无论编译和运行，都参考左边；
三、单例设计模式
/*
设计模式 解决某一类问题嘴行之有效的方法。
java中有23中设计模式
单例设计模式：解决一个类在内存中只存在一个对象
想要保证对象唯一
思想：
1.为了避免别的程序过多建立该类对象。所以先进制别的程序建立该类对象
2.还为了让别的程序能访问到该类对象。所以只好在本类中，自定义一个对象
3.为了方便其他类对该对象的访问。可以对外提供一些访问方式
步骤：
1.将构造函数私有化
2.类中建立一个本类对象
3.提供一个方法可以访问到该对象
对于事物该怎么描述还怎么描述
当需要将该类对象在内存中保证唯一时。就将以上的三步加上即可。
*/
class DanLi {
private int age; //该变量具有唯一性
private static DanLi dl = new DanLi(); //在该类中定义该类对象
private DanLi(){} //将该类的构造方法私有化
public static DanLi getDanLi() { //对外提供访问该类对象的方法
return dl;
}
public void setAge(int age) { //设置age
this.age = age;
}
public int getAge() { //输出age
return age;
}
}
class DanLiTest {
public static void main(String[] args) {
DanLi dl = DanLi.getDanLi();
DanLi ddl = DanLi.getDanLi();
dl.setAge(32);
System.out.println(ddl.getAge());
}
}
四、继承：
1，提高了代码的复用性。
2.让类与类之间产生了关系。有了这个关系。才有了多态的特性。
注意：千万不要为了获取其他类的功能。建华代码而继承；
必须是类与类之间有所属关系才可以继承，所属关系 is ， a
java语言中:java只支持单继承，不支持多继承、
因为多继承容易带来安全隐患：当多个父亲类中定义了相同功能。
当功能内容不同是，子类对象不确定要运行哪一个。
但是java保留这种机制。并用另一种体现形式来完成表示。多实现。
java支持多层继承。也就是一个继承体系。
如何使用一个继承体系中的功能呢？
想要使用体系。先查阅体系父类的描述。因为父类中定义的是该体系*性功能。
通过了解共性功能。就可以知道该体系的基本功能。
那么这个体系就可以基本使用了。
那么在具体调用时。要创建最子类的对象。为什么呢？
一是因为有可能父类不能创建对象
二是创建子类对象可以使用更多的功能。包括基本的也包括特有的
五、静态
/*
静态的使用
每一个应用中都有共性的功能
可以将这些共性的功能抽取出来。进行封装
建立一个工具类
发现问题
1.对象是用于封装特有数据的。可是ArrayTool工具类中并未封装特有数据
2.操作数组的每一个方法都没有用到类中的特有数据
这时就考虑让，让程序更严谨，是不需要对象的
可以将ArrayTool中的函数定义为static的，直接通过类名调用即可
将方法都静态后，可以方便与使用，但是还是可以被别的类建立对象的
为了更严谨，可以强制让该类不能建立对象
把该类的构造函数私有化，就可以让别的程序无法建立该类对象
*/
//建立工具类
class ArrayTool {
//把该类构造函数私有化
private ArrayTool(){}
//定义一个求取最大值的函数
public static int getMax(int[] arr) {
int max = 0;
for(int i = 1; i < arr.length; i++) {
if(arr[max] < arr[i]) {
max = i;
}
}
return arr[max];
}
//求取最小值
public static int getMin(int[] arr) {
int min = 0;
for(int i = 1; i < arr.length; i++) {
if(arr[min] > arr[i]) {
min = i;
}
}
return arr[min];
}
//数组排序 从小到大
public static void selectSort(int[] arr) {
for(int i = 0; i < arr.length - 1; i++) {
for(int j = i + 1; j < arr.length; j++) {
if(arr[i] > arr[j]) {
sort(arr, i, j);
}
}
}
}
//数组排序 从大到小
public static void bubbleSort(int[] arr) {
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr.length - i - 1; j++) {
if(arr[j] < arr[j + 1]) {
sort(arr, j, j + 1);
}
}
}
}
//数据交换
private static void sort(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//打印输出数组
public static void printArray(int[] arr) {
System.out.print(" [ ");
for(int i = 0; i < arr.length; i++) {
if(i != arr.length - 1) {
System.out.print(arr[i] + " , ");
} else {
System.out.println(arr[i] + " ] ");
}
}
}
}
//建立一个测试类
class ArrayToolTest {
public static void main(String[] args) {
int[] arr = {3,4,6,1,7,9,8};
int a = ArrayTool.getMax(arr);
p("最大值是:" + a);
int b = ArrayTool.getMin(arr);
p("最小值是:" + b);
//数组排序 排序前
ArrayTool.printArray(arr);
//排序 从小到大
ArrayTool.selectSort(arr);
//排序后
ArrayTool.printArray(arr);
//排序 从大到小
ArrayTool.bubbleSort(arr);
//排序后
ArrayTool.printArray(arr);
}
//建立一个特殊函数。可以用起代替输出语句
public static void p(Object obj) {
System.out.println(obj);
}
}
---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Unity开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------
详细请查看：<a href="http://edu.csdn.net" target="blank">http://edu.csdn.net</a>