面向对象的第一部分
面向对象的思想
:现在人们思考习惯的一种思想。
什么是对象:简单的理解,人就是一个对象,电脑也是一个对象,在程序中、类就是对象。(老师说的,一切开皆为对象)
面向对象的三大特征:封装,继承,多态。
描述一个事物,就两个个特征:属性、行为(方法)。
匿名对象:匿名对象只能被调用一次,是没有名字的对象。
例:
new Car().method();
new 类名().方法名();
可以将匿名对象作为实例参数来传递
例:
show(new Car());
实例:
class Car(){public void method(){System.out.println(".............");}}
class Main(){public static void main(String[] ages){show(new Car())}public static void show(Car c){c.method();}}
成员变量和局部变量的区别:
1,成员变量直接定义在类中。
局部变量定义在方法中,参数上,语句中。
2,成员变量在这个类中有效。
局部变量吸在自己所属的大括号有效,大括号结束,局部变量失去作用域。
3,成员变量存在于堆内存中,随着对象的产生而存在,消失而消失。
局部变量存在于栈内存中,随着所属区域的运行而存在,结束而释放。
构造函数:用于给对象进行初始化,是给与之对应的对象进行初始化,它具有针对性,函数中的一种。
特点:
1,该函数的名称和所在类的名称相同。
2,不需要定义返回值类型。
3,该函数没有具体的返回值。
实例:
class Person(){Person(){}}
记住:所有对象创建时,都需要初始化才可以使用。
注意事项:一个类在定义时,如果没有定义过构造函数,那么该类中会自动生成一个空参数的构造函数,为了方便该类创建对象,完成初始化。如果在类中自定义了构造函数,那么默认的构造函数就没有了。
一个类中,可以有多个构造函数,因为它们的构造函数名称都相同,所以只能通过参数列表来区分。所以,
一个类中如果出现多个构造函数,它们的存在是以重载体现的。
实例:
class Person(){Person(){}Person(String str){}Person(int a){}Person(String str, int a){}}
什么时候使用构造函数:
分析事物时,发现具体事物一出现,就具备了一些特征,那就将这些特征定义到构造函数内。
构造函数和一般函数有什么区别:
1,两个函数定义格式不同。
2,构造函数是在对象创建时,就被调用,用于初始化,而且初始化动作只执行一次。一般函数,是对象创建后,需要调用才执行,可以被调用多次。
构造代码块和构造函数有什么区别:
构造代码块:是给所有的对象进行初始化,也就是说,所有的对象都会调用一个代码块。
只要对象一建立,就会调用这个代码块。
构造函数:
是给与之对应的对象进行初始化,它具有针对性。
构造代码块实例:
制作帮助文档:
public class MianXiangDiuXiang_SixDay {
private MianXiangDiuXiang_SixDay() {
}
/* 返回最大值,此方法为遍历判断脚标值、得出脚标 */
/**
* 获取一个整形数组中的最大值
* @param arr 接收一个int类形的数组
* @return 会返回一个数组中的最大值
* */
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];
}
/* 返回最小值,此方法为遍历判断脚标的值、得出数值 */
/**
* 获取一个整形数组中的最小值
* @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 - 1; 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 - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr, j, j + 1);
}
}
}
}
/* 将两个值交换 */
/**
* 用于给数组中的两个值进行交换
* @param arr 接收一个int类形的数组,和两个int类型的整数
* */
private static void swap(int[] arr,int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
/* 把数组打印在控制台上 */
/**
* 用于给数组进行打印,打印形式:[elemet1,elemet2,elemet3......]
* @param arr 接收一个int类形的数组
* */
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] + "]");
}
}
}
}
制作API文档:
方法1.选择工程,在菜单Project->Genarate Javadoc
方法2.选择工程,鼠标右键菜单Export ,选择Java 下面的Javadoc ,点”next” 按钮
方法3.选择工程,在菜单File->Export ,选择Java 下面的Javadoc ,点”next” 按钮 然后
可以选择生成到Javadoc 文档中的内容( 一般选public 或protected) ,选存放目录( 默认即可) ,next下一步 ,此页全默认即可,再next 下一步 。
封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
好处:将变化隔离,便于使用,提高复用性,安全性。
封装原则:将不需要对外提供的内容都隐藏起来,
把属性都隐藏,提供公共方法对其访问。
单例设计模式:(定义单例设计建议使用饿汉式)
解决的问题:保证一个类在内存中的对象唯一性。
比如:多程序读取一个配置文件时,建议配置文件封装成对象。会方便操作其中数据,又要保证多个程序读取到的是同一个配置文件对象,就需要该配置文件对象在内存中是唯一的。
如何保证对象唯一性:
思想:1,不让其他程序创建该类对象。
2,在本类中创建一个本类对象。
3,对外提供方法,让其他程序获取这个对象。
步骤:
1,因为创建对象都需要构造函数初始化,只要被本类中的构造函数私有化,其他程序就无法再创建该类对象。
2,就在类中创建一个本类的对象。
3,定义一个方法,返回该对象,让其他程序可以通过方法就得到本类对象。(作用:可控)
代码体现:
1,私有化构造函数。
2,创建私有并静态的本类对象。
3,定义公有并静态的方法,返回该对象。
有两种方法:
第一种方法:饿汉式:(开发中使用此方法)
class Single(){
private Single(){} //私有化构造函数。
private static Single s = new Single(); //创建私有并静态的本类对象。
public static Single getInstance(){ //定义公有并静态的方法,返回该对象。
return s;
}
}
第二种方法:懒汉式:
class Single(){
private Single(){} //私有化构造函数。
private static Single s = null; //创建私有并静态的空对象。
public static Single getInstance(){ //定义公有并静态的方法,返回该对象。
if(s == null)
s = new Single(); //已创建的对象为本类对象。
return s;
}
}