零基础学习java（六）

java语言基础知识

1：包
(1)其实就是文件夹。
(2)作用：把同名称的类放到不同的文件夹下使用。
(3)格式： package xb.yb.zb;
(4)带包的类的编译和运行：
A:手动式：1:javac编译当前类文件。 2:手动建立包对应的文件夹。3:把a的class文件放到b的最终文件夹下。
4:通过java命令执行。注意了：需要带包名称的执行。  java con.it.HelloWorld

B:自动式a:javac编译的时候带上-d即可javac -d . HelloWorld.java
b:通过java命令执行。需要带包名称的执行。   javacon.it..HelloWorld
2：导包
(1)不同包下的类之间的访问。每次使用不同包下的类的时候，都需要加包的全路径。
  比较麻烦。这个时候，java就提供了导包的功能。
(2)格式： import xb.yb.zb.类名; 扩充格式：import xb.yb.zb.*;但是不建议使用这种做法。
(3)面试题：package,import,class的有没有顺序呢?
package > import > class

唯一  多个         多个
3：权限修饰符（访问权限）

	本类	同一包下	同一包下子类	不同包下无关类
private	Y
默认	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

常见的修饰符的使用(修饰的概念)

	类	成员变量	构造方法	成员方法
private		Y	Y	Y
默认	Y	Y	Y	Y
protected		Y	Y	Y
public	Y	Y	Y	Y
final	Y	Y		Y
static		Y		Y
abstract	Y			Y

默认一般类：public   成员变量：private    构造方法：public       成员方法：public
4：内部类：(1)把类定义在其他类的内部，就被称为内部类。(2)内部类的访问特点：
A：内部类可以直接访问外部类的成员，包括私有。B：外部类要访问内部类的成员，必须创建对象。
(3)内部类的分类：A:成员内部类a:private 访问的安全性b:static 访问的方便
B:局部内部类 a:带名字的(类)           b:不带名字的(对象)：局部内部类访问局部变量必须加final修饰。
(4)匿名内部类。本质：是继承类或者实现接口的子类匿名对象
格式： new 类名或者接口名() {
重写方法;
};

5：Object类
(1)是类层次结构的根类，所有的类都直接或者间接的继承自该类。
(2)成员方法： A:toString(),返回对象的字符串表示。 默认格式：包名.类名@哈希值的十六进制。
建议重写该方法。而且，不用自己动手。
B:getClass()      返回对象的字节码描述文件。C:hashCode()      返回对象的哈希值。可以理解为地址值。
D:finalize()      被对象的垃圾回收器调用，用于垃圾回收。
E:equals()             默认情况下，比较对象的地址值。建议重写该方法。而且，不用自己动手。
一般重写方法的时候：都是比较的是对象的成员变量值。
(3)==和equals()的区别?
A:==:a:基本类型 比较的是基本类型的值。b:引用类型 比较的是引用类型的地址值。
B:equals() 只能比较引用类型。默认比较地址值。
6：Scanner键盘录入(1)使用步骤：A:导包B:创建对象C:调用方法：(2)成员方法：    int nextInt()String nextLine()
7：String
(1)多个字符组成的一串数据。
(2)构造方法：A:String s = new String();B:String s = new String(byte[] bys);
C:String s = new String(byte[] bys,int index,int count);D:String s = new String(char[] chs);
E:String s = new String(char[] chs,int index,int count);F:String s = new String(String str);G:String s = "hello";
(3)String 的特点：
A:字符串一旦被赋值就不能被改变。值确定，内存地址中的内容不变可以改变引用。
B:String s = new String("hello")和String s = "hello";的区别，前者创建了2个对象后者创建了1个对象
字符串的比较

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1==s2);             //false
System.out.println(s1.equals(s2));   //true
String s3 = new String("hello");      
String s4 = "hello";
System.out.println(s3==s4);             //false
System.out.println(s3.equals(s4));//true
String s5 = "hello";
String s6 = "hello";
System.out.println(s5==s6);             //true
System.out.println(s5.equals(s6));   //true
String str1 = "hello";
String str2 = "world";
String str3 = "helloworld";
System.out.println(str3==str1+str2);       //false
System.out.println(s3.equals(str1+str2)); //true

(4)常见方法：
A:判断功能
boolean equals(Object obj)                        //判断字符串对象是否相同
boolean equalsIgnoreCase(String str)       //判断字符串对象是否相同不区分大小写
boolean contains(String str)                       //判断字符串是否包含str
boolean startsWith(String str)                    //判断字符串对象是否以str开头
boolean endsWith(String str)                       //判断字符串对象是否以str结尾
boolean isEmpty()                                      //判断字符串对象是否为空
B:获取功能
int length()                         // 获取字符串长度。
char charAt(int index)        // 获取字符串指定位置的字符
int indexOf(int ch)               // 获取字符串指定字符的字符串所在位置
int indexOf(int ch,int fromIndex)   // 获取字符串指定字符的字符串所在位置从formindex开始
int indexOf(String str,int fromIndex) // 获取字符串指定字符串的字符串所在位置从formindex开始
String substring(int start)                // 获取字符串指定子串
String substring(int start,int end)    // 获取字符串指定子串指定开始和结尾的位置
C:转换功能
byte[] getByteds()                                //字符串转字节数组
char[] toCharArray()                            //字符串转字符数组
String toLowerCase()   //字符串转小写
String toUpperCase() //字符串转大写
String concat(String str)                   //字符串转链接
D:其他功能
String replace(char old,char new)    //字符串字符替换
String replace(String old,String new)//字符串替换
String trim()                                         //字符串去空
int compareTo(String str)                   //字符串比较大小
int compareToIgnoreCase(String str) //字符串比较大小不区分大小写

8:StringBuffer/StringBuilder
(1)字符串缓冲区类。
(2)String,StringBuffer/StringBuilder的区别
A:String的字符串长度固定。而StringBuffer/StringBuilder的字符串长度是可以改变的。
B:StringBuffer是线程安全的，效率低。 StringBuilder是线程不安全的，效率高。
(3)构造方法：
A:StringBuffer sb = new StringBuffer();    B:StringBuffer sb = new StringBuffer(50);
C:StringBuffer sb = new StringBuffer("hello");
(4)成员方法：
A:添加功能 append,insert。 B:删除功能   delete,deleteCharAt。C:替换功能        replace。
D:截取功能 substring。E:反转功能 reverse
(5)两个类可以相互转换，其实是为了使用别人的功能。
9:数组操作
(1)基本操作：1:遍历 2:获取最值3:数组反转 4:基本查表法5:基本查找
(2)高级操作：A:排序 冒泡:相邻元素依次比较。

public static void bubbleSort(int[] arr) {
for(int x=0; xarr[y+1]){
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;}}
}
}

选择:用最小索引和别人都比较。

public static void selectSort(int[] arr) {
for(int x=0; xarr[y]){
int temp = arr[y];
arr[y] = arr[x];
arr[x] = temp;
}
}
}
}

B:查找二分查找:从中间，可以截取一半。前提：数组有序。

public static int getIndex(int[] arr,int value) {
int max = arr.length-1;
int min = 0;
int mid = (max+min)/2;
while(arr[mid]!=value){
if(arr[mid]>value) {
max = mid - 1;
}else if(arr[mid] max) {
return -1;
}
mid = (max+min)/2;
}
return mid;
}

(3)Arrays
A:针对数组进行操作的工具类。B:三个a:把数组转成字符串toString。     b:排序sort   c:查找binarySearch
C:看Arrays工具类的源码。
10:Integer
(1)为了对基本类型的数据进行更多的操作的，java就针对每种基本类型的数据提供了对应的包装类类型。
(2)对应的类型

基本类型	byte	short	int	long	float	double	char	boolean
对应包装	Byte	Short	Integer	Long	Float	Double	Character	Boolean

(3)构造方法：
A:Integer i = new Integer(100);B:Inreger i = new Integer("100");注：这里的字符串必须是由数组字符组成。
(4)成员方法： A:把字符串转换成int类型。parseInt(String s)
B:返回Integer类型的int类型值intValue()。C:把int类型转换成Integer类型valueOf()
(5)JDK5的新特性：A:自动装箱基本类型 -- 引用类型。 B:自动拆箱        引用类型 -- 基本类型
Integer i = 100;               //自动装箱
i += 200;                         //自动拆箱,自动装箱