1.内部类
- 在一个类里面定义另一个内部类;
- 内部类首先能够直接调用外部类各个属性(包括私有属性,但是外部类无法访问内部类内部属性);
- 其次相同包里面的类无法直接访问使用该内部类;
- 分为匿名内部类(一般用于在在监听器中个,比如键盘监听),成员内部类 ,局部内部类(定义在方法里面);
- 成员内部类分为非静态内部类和静态内部类(由static 修饰);
匿名内部类结构:
new 父类构造器(实参)接口(){
类体
} - 在文件格式下,外部类与内部类用$ 隔开;比如在类Person中创建一个内部类Per,则文件下它的名字是Person$per;
- 静态内部类无法使用外部类的普通属性,只能使用静态属性;
- 成员内部类:
public class Outer {
public static void main(String[] args) {
Face.Nose n = new Face().new Nose();//实例化内部类
n.breath();//调用内部类的方法;
Face.Ear e = new Face.Ear();//与上面的非静态内部类进行比较,发现还是有很大的不同的;
e.listen();
}
}
class Face {
int type = 4;
String nose = "sdd"
class Nose {//非静态内部类;
String nose = "鼻子";
void breath() {
System.out.println(type);//内部类可以直接使用外部类的属性;
System.out.println(Face.this.nose);//如果外部类和内部类属性名一致则必须要指明是那个的属性;
System.out.println("呼吸");
}
}
static class Ear {
void listen() {
// System.out.println(type);//这个由于在外部类中,type不属于静态属性所以,在静态内部类中无法调用;
System.out.println("听力");
}
}
}
2.字符串
Java中的字符串就是Unicode字符序列;Java中没有内置的字符串类型,而是在标准Java类库中提供了一个预定义的类String,每一个用双引号引起来的就是字符串; String是不可变字符序列,因为在String类中,它的值是由final修饰的;
public class Mytest {
public static void main(String[] args) {
String str = "abc";//放在常量池
String str1 = "abc";
String str2 = new String("abcd");
String str3 = new String("abcd");
System.out.println(str.equals(str1));//这里比较了它的值;true
System.out.println(str==str1);//因为这里只比较了他的对象;true
System.out.println(str2.equals(str3));//true
System.out.println(str2==str3);//这里只比较的是它的对象;false
}
}
至于在String类中自带的方法之类的下次看了源码之后再说;
- indexOf(String):返回这个字符所在的位置(第一个字符的位置);
- lastIndexOf(String):返回这个最后的字符所在的位置;
- split(String):返回的是字符串;而且在split中的字符串会被去除; 起到一个分割的作用;例如:Hello,split(e),得到的结果就是H,llo;
- trim():去除字符串的首尾 所有空格;
- equalsIgnoreCase(String):这是比较字符串忽略大小写;
- substring(int):这个方法用来从数字下标的字符开始选取一段字符串;
- toLowercase() :这个方法是把字符串全部变成小写;
- toUppercase():这个方法是将字符串全部变成大写;
- replace(“老字符”,“新字符”)把老字符替换成新字符;
- 一个隶属于system的方法;直接这样使用:system.arraycopy(obj src,int1 ,obj2,int2,length):这里面src是一个数组对象,int1是第一个数组要从哪里开始复制的起始点,obj2那里是复制到的对象位置, int2的意思是第二个对象开始复制的起始点,至于最后的length是指第二个对象复制第一个的总长度;
3.StringBuilder和StringBuffer
StringBuilder线程不安全,但是效率高;StringBuffer线程安全,但是效率不高;
StringBuilder是可变序列,主要也是指建立一个新数组将老数组给替换掉;
public class TextStringBuilder {
public static void main(String[] args) {
StringBuilder str = new StringBuilder();//根据源码可以知道初始化的长度是16
StringBuilder str1 = new StringBuilder("abcd");
StringBuffer str3 = new StringBuffer();
str.append("ssd");//在str字符后面添加ssd字符串;
str.delete(0, 1);//删除0到1之间的字符;
str.insert(0, "c");//在0的位置添加c字符
str.reverse();//就是将字符串反向;
for(int i=0;i<1000;i++) {
str1.append(i);
}
System.out.println(str);
System.out.println(str1);
}
}
在源码中StringBuilder类和类StringBuilder继承抽象类AbstractStringBuilder。
StringBuilder类默认的初始长度是16;
toString()方法;(只是以字符串形式输出);
tocharAt():显示出指定位置的字符;
一个构造器里可以直接调用另一个构造器,在一个类中;
4.多维数组
之前写过一维数组的创建和使用,对于多维数组好像没有记录,所以现在记一下;定义数组的时候要确定它的大小(也就是需要的内存空间);
public class Myarray {
public static void main(String[] args) {
int[][] a = {//在定义多维数组的同时,给其赋值;
{1,2},
{2,3}
};
int[][] b = new int[5][2]; //只是对其进行定义,之后赋值;
System.out.println(a[1][1]);
}
}
以下是我理解的多维数组的内存结构,当然,为了便于画图,我给数组的前后都定义了大小为2;
一维数组可以理解成一条x轴,而二维数组可以理解为x,y轴;
部分方法:
- Arrays.toString(int a[]):打印出a数组的内容;
- Arrays.binarySearch(int a[],int d):返回一个索引,就是d在数组a的下标位置;
- 当然可以通过foreach即for(类型 :数组)来循环读取b数组的内容;
5.冒泡排序
比较相邻的元素,然后将第一个元素比第二个元素小的顺序排列;第一次排序后得到最大的那个数;
public class TextBubbleSort {
public static void main(String[] args) {
int[] values= {//定义一个数组;
3,2,5,6,8,7,4,6,5,12,54,65,65,44,2,5,2,5,5,55,5,56,87,98
};
for(int i=0;i<values.length;i++) {//让数组循环values.length次
for(int j=0;j<values.length-1-i;j++) {//这里面的i可有可无,但是有的话可以使循环次数减少,因为每一次循环都可以得到一个最大值;
if(values[j]>values[j+1]) {
int t = values[j];
values[j] = values[j+1];
values[j+1] = t;
System.out.println(Arrays.toString(values));
}
System.out.println("###########");
}
}
// for(int p:values) {
// System.out.println(p);
// }
}
}
6.二分法检索
二分法查找也成称为折半查找(数组必须是已经排好序的),每一次查找都减少一半 ;
public class TextbanirySearch {
public static int MyBaniry(int[] arr, int value) {
int low = 0;
int high = arr.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] == value) {
return mid;
}
if (arr[mid] > value) {
high = mid - 1;
}
if (arr[mid] < value) {
low = mid + 1;
}
}
return -1;
}
public static void main(String[] args) {
int[] values = { 3, 2, 5, 6, 8 };
int value = 2;
Arrays.sort(values);
System.out.println(Arrays.toString(values));
System.out.println(MyBaniry(values, value));
}
}
以上是一个二分法的方法;
7.包装类
已知基本的数据类型有8种,因此包装类也有8中种,将其做成表格:
基本数据类型 | 包装类 |
---|---|
int | Integer |
byte | Byte |
short | Short |
char | Character |
boolean | Boolean |
long | Long |
float | Float |
double | Double |
在Integer包装类中:
public class MyInteger {
public static void main(String[] args) {
Integer i = new Integer(100);
System.out.println(Integer.toHexString(i));//答案是十六进制0X64
Integer i2 = Integer.parseInt("123");
System.out.println(i2);
Integer i3 =1000;//相当于是Integer i3 = new Integer(1000);JDK1.5之后有的自动装箱;
int i4 = new Integer(1000);//相当于是 new Integer(1000).intValue();
}
}
- toHexString(i):将i的值转换为16进制;
- Integer.parseInt(String):将其中的字符串转化为数字,当然字符串是以数字的形式出现,比如“123”,“3”等;
- 还有intValue方法可以将其转化为数字;
- 在Integer中[-128,127]之间的数可以被直接当做基本类型数据来使用;
其他的数据类型都差不多;所以就不一一的给自己进行描写,我感觉应该还行;
8.时间类
(java.util.Date)
因为在Date类中大部分的方法都已经不建议使用了,所以看了一圈大概就这么多的方法。
public class TextMydata {
public static void main(String[] args) {
Date d1 = new Date(1);
Date d2 = new Date(2);
boolean b = d1.after(d2);//还有一个before
System.out.println(b);
System.out.println(d1.getTime());
}
}
(DateFormat)
这个类看源码发现是一个抽象类,抽象类就是拥有抽象方法还无法继承的类;所以在创建对象的时候,只能借助他的子类,而无法直接用这个类创建,它的子类是SimpleDateFormat;(把时间转换为字符串或者把字符串转化为时间)
public class TextDateFormat {
public static void main(String[] args) {
//千万单词不要错,在API里面就是这么规定的,一旦单词错了,基本上日期显示就不对了;还有大写W,表示一月里面的周数,
DateFormat df = new SimpleDateFormat("yyyy-MM-dd w hh:mm:ss");
Date d = new Date(System.currentTimeMillis());
// d.setTime(145456455456l);
String str = df.format(d);
System.out.println(str);
String str1 = "1238,5,7";
DateFormat df2 = new SimpleDateFormat("yyyy,dd,MM");
try {
Date d2 = df2.parse(str1); //把字符串转格式成日期;
System.out.println(d2);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
(Calendar)
这个类可以对时间进行计算,当然也可以进行定义,但是Calendar也是一个抽象类当要建立对象时还是要依靠他的子类。
public class TextCalendar {
public static void main(String[] args) {
Calendar cd = new GregorianCalendar();
//如果不定义时间,那么他就会使用当前的时间;
cd.set(1745, Calendar.JULY, 25, 12, 22, 55);
cd.add(Calendar.DAY_OF_MONTH, 10);//可以进行时间的加减;
Date d = cd.getTime();
System.out.println(d);
}
}
总结(通过输出得到所需要的简单日历):
public class TextCanlandar {
public static void main(String[] args) {
while (true) {
System.out.println("\n请按要求输入日期(2011-02-4):\n");
Scanner scanner = new Scanner(System.in);
System.out.println("日\t一\t二\t三\t四\t五\t六\n");
String input = scanner.next();
DateFormat dateformat = new SimpleDateFormat("yyyy-MM-dd");
try {
Date day = dateformat.parse(input);
Calendar cd = new GregorianCalendar();
cd.setTime(day);
cd.set(Calendar.DATE, 1);
int weekday = cd.get(Calendar.DAY_OF_WEEK);
int Maxday=cd.getActualMaximum(Calendar.DAY_OF_MONTH);
for (int i = 1; i < weekday; i++) {
System.out.print("\t");
}
for (int i = 1; i < Maxday; i++) {
System.out.print(i + "\t");
if ((i + weekday - 1) % 7 == 0) {
System.out.println("\n");
}
}
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
以后学好了,还记得的情况下,我就把他做成程序;