黑马程序员-基础知识梳理2
2013-07-10 23:49
274 查看
------- android培训、java培训、期待与您交流!
----------
数组的第二种创建方式:元素类型[] 数组名 = new 元素类型[]{元素1,元素2.。。。。};
int [] arr = new int[]{1,2,3,4,5};
int[] arr ={1,2,3,4,5};
异常代码:
Arrary Index out of boundsException:3:操作数时,访问到了数组不存在的角标
NullPointer Exception :空指针异常:当引用没有任何指向,值为NULL的情况,该引用还用于操作实体。
选择排序:先以0角标的数与其他数比较,确定0角标的位置的数之后再以相同的方法确定1角标,2角标。。。。。
选择排序特点:内循环结束一次,最值出现在头角标位置。
冒泡排序:相邻2个元素比较,如果符合条件,换位置,一轮过后,最值出现在数组的最后一个元素上,下一轮的时候,就不用比较最后一个元素了。
数组元素的查找:如果要找的数不在数组内,那么就返回一个-1
折半查找的2种方式:
练习:有一个有序的数组,想要将一个元素插入到该数组中,还要保证该数有序;
思路:1、先查找该数是否在该数组存在,如果找到了,就直接插在该数的位置
2、如果不存在,可以利用折半查找的方式在return -1 的地方将其改成return min;这个min就是要插入位置的角标
练习:
十进制->二进制
十进制->16进制
查表法 三种进制整合
二维数组
int arr[][] = new int[3][4]; //定义了名为arr 的二维数组,二维数组里有三个一维数组,每个一维数组里面有4个元素。3指二维数组的长度
二维数组的应用
练习:求二维数组的所有数的和;
int
数组定义方式:
一位数组:int[] x; int y[];
二维数组: int [][] x;int []x[];int x[][];
习题:
1 。 int[] x,y[]; x是一位数组,y是二维数组; 拆开来分析:int[] x; int[] y[];
上面的定义作为一个大前提;
x[0]= y;错 ,二维数组赋值给一位数组的一个元素;
y[0]=x;对
y[0][0]=y; 错
x[0][0]= y;错
y[0][0]= x[0];对
x=y;错
面向对象:将功能封装进对象,强调具备了功能的对象。
类:对现实生活种事物的描述
对象:就是这类事物实实在在存在的个体
成员变量:存在堆内存中,因为对象存在,才在内存中存在;
布局变量:存在栈内存中
作用范围:成员变量作用于整个类中,布局变量作用于函数或者语句中。
匿名对象使用环境:1.当对对想的方法只调用一次,可以用匿名对象来完成,这样比较简化。如果对一个对象进行多个成员调用,必须对这个对象取名字。
2.可以将匿名对象作为实际参数进行传
new Car().num=5;
封装:是指隐藏对象的属性和实现细节,仅对外提供访问方式
构造函数:
特点 :
1函数名与类名相同
2不用定义返回值
3不可以写return语句
对象一建立,就会调用与之对应的构造函数
构造函数的作用:可以用于给对象进行初始化
构造函数的细节:
当一个类中没有定义构造函数,那么系统会默认给该类加入一个空参数的构造函数,如果有定义构造函数,默认构造函数就会消失。
构造函数在同一个类中可以有多个,只要参数列表不同就行。
构造函数和一般方法的区别:
构造函数在对象一建立就运行。给对象进行初始化;而一般方法是对象调用后才执行,是给对象添加对象具备的功能的
一个对象建立,构造函数只运行一次,而一般方法可以被该对象调用多次。
构造代码块:给对象进行初始化,而且优先于构造函数执行。
与构造函数的区别:
构造代码块是给所有对象进行统一初始化。
构造代码块中定义的是不同对象共性的初始化内容。
this 代表什么?
this 代表他所在函数所属对象的引用;
this 作用:用于区分局部变量和成员变量的同名情况;
this的应用:当定义类中功能时,该函数内容要用到调用该函数的对象时,这时用this来表示这个对象,但凡本类功能内部使用了本类对象,都用this表示。
构造函数间互相调用只能用this,构造函数只能被构造函数调用。
this(参数列表);
不带点;this语句只能放在构造函数的第一行;因为初始化动作要先执行。
public static void main(String[] args)
主函数:是一个特殊的函数,作为程序的入口,可以被jvm调用。
主函数的定义:
public:代表这该函数访问权限是最大的。
static:代表着主函数随着类的加载就已经存在了
void:主函数没有具体的返回值
main:不是关键字,但是是一个特殊的单词,可以被JVM调用
(String[] args):函数的参数,参数类型是一个数组,该数组中的元素是字符串类型的数组。主函数是固定格式的JVM识别。jvm在调用时,传入的是new String[0];
静态变量的定义环境?
当对象中出现共享数据时,该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
静态函数的定义环境:当功能内部没用访问到飞静态数据时(对象的特有数据)没那么该功能可以定义成静态的。
将方法静态后可以方便使用,但该类还是可以被其他程序建立对象,可以通过将构造函数私有化来优化。
static关键字:
用法:是一个用来修饰成员变量,成员函数的修饰符
当用static修饰后,该成员可以直接 被类名调用,不需要new对象。
static特点:
1。随着类的加载而加载,随着类消失而小时,生命周期长。
2。优于对象存在。
3。被所有对象共享
4。被类名直接调用
静态注意事项:
1.静态方法只能访问静态成员,非静态方法可以访问静态,非静态成员。
2.静态方法中不能定义this,super关键字;
因为静态优先于对象存在。
实力变量与类变量的区别:
1、存放位置:类变量随着类的加载而存在于方法中;实例变量随着对象的建立而存在于堆内存中。
2、生命周期:类变量随着类的消失而小时,实例变量随着对象的消失而消失
帮助文档的编写
/**
功能
@author xx
@ version V1.1
*/
在成员方法前面加上
/**
实现功能
@param 参数名 功能
.......
*/
命令:javadoc -d myhelp -authot -version java名.java
*/
API: APPLY PROGRAM INTERFACE
静态代码块的执行语句:
static{
执行语句;
}
Person p =new Person("zhangsan",20);
该语句做了什么?
1.加载person.class 到内存中;
2、执行该类的static代码块,如果有的,给person.class类进行初始化;
3、在堆内存中开辟空间,分配内存地址;
4、在堆内存中建立对象的特有属性,并进行默认初始化;
5、对属性进行显示初始化;
6、对对象进行构造代码块初始化
7、对对象进行队形的构造函数初始化
8、将内存地址复制给站内存中的P变量。
设计模式:解决某一类问题最行之有效的方法
java中有23中设计模式.
单例设计模式:解决一个类在内存只有一个对象
想要保证对象唯一:
1.为了避免其他程序过多建立该类的对象,先禁止其他程序建立该类的对象;
2.为了让其他程序可以访问该类的对象,只好在本类中定义一个对象;
3.为了方便其他程序对自定义对象的访问,可以对外提供一个访问方式;
这三步的代码实现:
1.将构造函数私有化
2.在类中建立一个本类的对象
3.提供一个方法可以获取该对象
private student(){}
private static student s = new student
public static student getInstance(){
return s;
}
package cn.itcast.day2;
public class lanhan_ehan {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
//懒汉式对象是方法被调用时,才被初始化,也叫对象的延迟加载。
static class Single{
private static Single s = null;
private Single(){};
public static Single getInstance(){
if(s==null){
synchronized(Single.class)
{
s= new Single();
return s;
}
}
return s;
}
}
//饿汉式:single 类一进内存,就已经创建好对象了。
static class Single1{
private Single1(){};
private static Single1 s = new Single1();
public static Single1 getInstance(){
return s;
}
}
}
----------
数组的第二种创建方式:元素类型[] 数组名 = new 元素类型[]{元素1,元素2.。。。。};
int [] arr = new int[]{1,2,3,4,5};
int[] arr ={1,2,3,4,5};
异常代码:
Arrary Index out of boundsException:3:操作数时,访问到了数组不存在的角标
NullPointer Exception :空指针异常:当引用没有任何指向,值为NULL的情况,该引用还用于操作实体。
选择排序:先以0角标的数与其他数比较,确定0角标的位置的数之后再以相同的方法确定1角标,2角标。。。。。
选择排序特点:内循环结束一次,最值出现在头角标位置。
冒泡排序:相邻2个元素比较,如果符合条件,换位置,一轮过后,最值出现在数组的最后一个元素上,下一轮的时候,就不用比较最后一个元素了。
public class Sort { public static void main(String[] args){ int[] arr = {9,2,4,3,5,1}; int[] arr1 = {11,3,88,22,13,52,1}; printarr(arr); selectSort(arr); printarr(arr); printarr(arr1); bubbleSort(arr1); printarr(arr1); } /** * 该方法实现冒泡排序 * @param arr */ 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+1]<arr[j]){ swap (arr,j+1,j); } } } } /** * 该方法实现选择排序,让数组升序排列 * @param arr */ 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); } } } } /** * 该方法实现对数组内2个元素之间的位置互换 * @param arr * @param i * @param j */ public static void swap(int[] arr,int i,int j){ int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } /** * 该方法实现对数组的打印 * @param arr */ public static void printarr(int[] arr) { for(int i=0;i<arr.length;i++){ if(i!=arr.length-1) System.out.print(arr[i]+","); else System.out.println(arr[i]); } } }希尔排序是最高效的排序。
数组元素的查找:如果要找的数不在数组内,那么就返回一个-1
折半查找的2种方式:
public class halfSearch { public static void main(String[] args){ int[] arr = {1,2,9,12,18}; int temp1=halfSearch1(arr,2); int temp2=halfSearch1(arr,22); int temp3=halfSearch2(arr,12); int temp4=halfSearch2(arr,22); System.out.println(temp1); System.out.println(temp2); System.out.println(temp3); System.out.println(temp4); } /** * 这是折半查找的第一种方式 * @param arr * @param key * @return */ public static int halfSearch1(int[] arr,int key) { int mid,min,max; max = arr.length-1; min = 0; mid=(max+min)>>1; while(key!=arr[mid]){ if(key>arr[mid]){ min=mid+1; } else if (key<arr[mid]){ max= mid-1; } if (min>max) { return -1; } mid=(max+min)>>1; } return mid; } /** * 这是折半查找的第二种方式 * @param arr * @param key * @return */ public static int halfSearch2(int[] arr, int key){ int min,max,mid; min=0; max=arr.length-1; mid=(max+min)>>1; while(max>=min){ if(key>arr[mid]){ min=mid+1; } else if(key<arr[mid]){ max=mid-1; } else return mid; mid=(max+min)>>1; } return -1; } }
练习:有一个有序的数组,想要将一个元素插入到该数组中,还要保证该数有序;
思路:1、先查找该数是否在该数组存在,如果找到了,就直接插在该数的位置
2、如果不存在,可以利用折半查找的方式在return -1 的地方将其改成return min;这个min就是要插入位置的角标
练习:
十进制->二进制
十进制->16进制
package cn.itcast.day2; public class decimalToBinaryAndHex { public static void main(String[] args){ int num=12; toBin(num); toHex(num); } public static void toBin(int num){ StringBuffer sb=new StringBuffer(); while(num!=0){ sb.append(num&1); num = num >>> 1; } System.out.println(sb.reverse()); } public static void toHex(int num){ StringBuffer sb = new StringBuffer(); while(num!=0){ int temp=num&15; if(temp>10) sb.append((char)(temp-10+'A')); else sb.append(temp); num = num >>>4; } System.out.println(sb.reverse()); } }
查表法 三种进制整合
package cn.itcast.day2; public class jinzhizhenghe { public static void main(String[] args){ int num = 78; toBin(num);//验证二进制 toHex(num);//验证16进制 toOct(num);//验证8进制 } //查表法将3种进制转换共同的地方抽取出来封装成一个方法 public static void trans( int num ,int base,int offset){ char[] chs = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; StringBuffer sb = new StringBuffer(); char [] arr =new char[32]; int pos =arr.length; while (num!=0){ int temp = num & base; arr[--pos] = chs[temp]; num=num>>>offset; } for(int i=pos;i< bb81 ;arr.length;i++){ if(i!=arr.length-1) System.out.print(arr[i]); else System.out.println(arr[i]); } } //转2进制 public static void toBin(int num) { trans(num ,1,1); } //转8进制 public static void toOct(int num){ trans(num,7,3); } //转16进制 public static void toHex(int num){ trans(num,15,4); } }
二维数组
int arr[][] = new int[3][4]; //定义了名为arr 的二维数组,二维数组里有三个一维数组,每个一维数组里面有4个元素。3指二维数组的长度
二维数组的应用
练习:求二维数组的所有数的和;
int
package cn.itcast.day2; public class arrayPractise { /**练习:求二维数组里所有数的和 * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub int[][] arr = {{1,3,5,5,2},{23,13,2},{23,1},{19,57}}; int sum = 0; for(int i=0;i<arr.length;i++){ for(int j=0;j<arr[i].length;j++){ sum += arr[i][j]; } } System.out.println(sum); } }
数组定义方式:
一位数组:int[] x; int y[];
二维数组: int [][] x;int []x[];int x[][];
习题:
1 。 int[] x,y[]; x是一位数组,y是二维数组; 拆开来分析:int[] x; int[] y[];
上面的定义作为一个大前提;
x[0]= y;错 ,二维数组赋值给一位数组的一个元素;
y[0]=x;对
y[0][0]=y; 错
x[0][0]= y;错
y[0][0]= x[0];对
x=y;错
面向对象:将功能封装进对象,强调具备了功能的对象。
类:对现实生活种事物的描述
对象:就是这类事物实实在在存在的个体
成员变量:存在堆内存中,因为对象存在,才在内存中存在;
布局变量:存在栈内存中
作用范围:成员变量作用于整个类中,布局变量作用于函数或者语句中。
匿名对象使用环境:1.当对对想的方法只调用一次,可以用匿名对象来完成,这样比较简化。如果对一个对象进行多个成员调用,必须对这个对象取名字。
2.可以将匿名对象作为实际参数进行传
new Car().num=5;
封装:是指隐藏对象的属性和实现细节,仅对外提供访问方式
构造函数:
特点 :
1函数名与类名相同
2不用定义返回值
3不可以写return语句
对象一建立,就会调用与之对应的构造函数
构造函数的作用:可以用于给对象进行初始化
构造函数的细节:
当一个类中没有定义构造函数,那么系统会默认给该类加入一个空参数的构造函数,如果有定义构造函数,默认构造函数就会消失。
构造函数在同一个类中可以有多个,只要参数列表不同就行。
构造函数和一般方法的区别:
构造函数在对象一建立就运行。给对象进行初始化;而一般方法是对象调用后才执行,是给对象添加对象具备的功能的
一个对象建立,构造函数只运行一次,而一般方法可以被该对象调用多次。
构造代码块:给对象进行初始化,而且优先于构造函数执行。
与构造函数的区别:
构造代码块是给所有对象进行统一初始化。
构造代码块中定义的是不同对象共性的初始化内容。
this 代表什么?
this 代表他所在函数所属对象的引用;
this 作用:用于区分局部变量和成员变量的同名情况;
this的应用:当定义类中功能时,该函数内容要用到调用该函数的对象时,这时用this来表示这个对象,但凡本类功能内部使用了本类对象,都用this表示。
构造函数间互相调用只能用this,构造函数只能被构造函数调用。
this(参数列表);
不带点;this语句只能放在构造函数的第一行;因为初始化动作要先执行。
public static void main(String[] args)
主函数:是一个特殊的函数,作为程序的入口,可以被jvm调用。
主函数的定义:
public:代表这该函数访问权限是最大的。
static:代表着主函数随着类的加载就已经存在了
void:主函数没有具体的返回值
main:不是关键字,但是是一个特殊的单词,可以被JVM调用
(String[] args):函数的参数,参数类型是一个数组,该数组中的元素是字符串类型的数组。主函数是固定格式的JVM识别。jvm在调用时,传入的是new String[0];
静态变量的定义环境?
当对象中出现共享数据时,该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
静态函数的定义环境:当功能内部没用访问到飞静态数据时(对象的特有数据)没那么该功能可以定义成静态的。
将方法静态后可以方便使用,但该类还是可以被其他程序建立对象,可以通过将构造函数私有化来优化。
static关键字:
用法:是一个用来修饰成员变量,成员函数的修饰符
当用static修饰后,该成员可以直接 被类名调用,不需要new对象。
static特点:
1。随着类的加载而加载,随着类消失而小时,生命周期长。
2。优于对象存在。
3。被所有对象共享
4。被类名直接调用
静态注意事项:
1.静态方法只能访问静态成员,非静态方法可以访问静态,非静态成员。
2.静态方法中不能定义this,super关键字;
因为静态优先于对象存在。
实力变量与类变量的区别:
1、存放位置:类变量随着类的加载而存在于方法中;实例变量随着对象的建立而存在于堆内存中。
2、生命周期:类变量随着类的消失而小时,实例变量随着对象的消失而消失
帮助文档的编写
/**
功能
@author xx
@ version V1.1
*/
在成员方法前面加上
/**
实现功能
@param 参数名 功能
.......
*/
命令:javadoc -d myhelp -authot -version java名.java
*/
API: APPLY PROGRAM INTERFACE
静态代码块的执行语句:
static{
执行语句;
}
Person p =new Person("zhangsan",20);
该语句做了什么?
1.加载person.class 到内存中;
2、执行该类的static代码块,如果有的,给person.class类进行初始化;
3、在堆内存中开辟空间,分配内存地址;
4、在堆内存中建立对象的特有属性,并进行默认初始化;
5、对属性进行显示初始化;
6、对对象进行构造代码块初始化
7、对对象进行队形的构造函数初始化
8、将内存地址复制给站内存中的P变量。
设计模式:解决某一类问题最行之有效的方法
java中有23中设计模式.
单例设计模式:解决一个类在内存只有一个对象
想要保证对象唯一:
1.为了避免其他程序过多建立该类的对象,先禁止其他程序建立该类的对象;
2.为了让其他程序可以访问该类的对象,只好在本类中定义一个对象;
3.为了方便其他程序对自定义对象的访问,可以对外提供一个访问方式;
这三步的代码实现:
1.将构造函数私有化
2.在类中建立一个本类的对象
3.提供一个方法可以获取该对象
private student(){}
private static student s = new student
public static student getInstance(){
return s;
}
package cn.itcast.day2;
public class lanhan_ehan {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
//懒汉式对象是方法被调用时,才被初始化,也叫对象的延迟加载。
static class Single{
private static Single s = null;
private Single(){};
public static Single getInstance(){
if(s==null){
synchronized(Single.class)
{
s= new Single();
return s;
}
}
return s;
}
}
//饿汉式:single 类一进内存,就已经创建好对象了。
static class Single1{
private Single1(){};
private static Single1 s = new Single1();
public static Single1 getInstance(){
return s;
}
}
}
相关文章推荐
- 黑马程序员——java基础(IO部分知识梳理)下
- 黑马程序员-基础知识梳理8
- 黑马程序员-基础知识梳理4
- 黑马程序员-基础知识梳理3
- 黑马程序员-基础知识梳理5
- 黑马程序员-基础知识梳理7
- 黑马程序员——java基础(IO部分知识梳理)上
- 黑马程序员--c#基础知识梳理
- C#基础知识梳理系列十一:垃圾回收机制
- 黑马程序员-------.net基础知识九
- C#基础知识梳理系列五:委托与事件
- 黑马程序员-面向对象基础知识
- C#基础知识梳理系列四:C#类成员:方法
- Docker容器学习梳理--基础知识(2)
- 黑马程序员 Java基础知识
- 黑马程序员_01Java基础知识总结
- Python基础知识梳理 - 第01部分
- 黑马程序员_学习日记2_有关C#基础知识总结归纳之对象和类型
- jQuery HTML相关的基础知识梳理
- 黑马程序员-C语言基础知识-数据