这是本人看菜鸟教程Java教程之后觉得可以复习巩固的知识点
1.
Integer.SIZE 32
Integer.MIN_VALUE=-2147483648
Integer.MAX_VALUE=2147483647
2.
隐含强制类型转换
-
1、 整数的默认类型是 int。
-
2. 小数默认是 double 类型浮点型,在定义 float 类型时必须在数字后面跟上 F 或者 f。
3.
-
default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
-
protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
4.
访问控制和继承
请注意以下方法继承的规则:
-
父类中声明为 public 的方法在子类中也必须为 public。
-
父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。
-
父类中声明为 private 的方法,不能够被子类继承。
5.
父类中的 final 方法可以被子类继承,但是不能被子类重写。
final 类不能被继承,没有类能够继承 final 类的任何特性。
synchronized 关键字声明的方法同一时间只能被一个线程访问。
6.
如果TransTest 类的一个对象被序列化,i的内容不被保存,但j的将被保存。
Java代码
package com.test; class TransTest {
transient int i; //不需要保存
int j; //需要保存
}
7.
public class MyRunnable implements Runnable { private volatile boolean active; public void run() { active = true; while (active) // 第一行 { // 代码 } } public void stop() { active = false; // 第二行 } }
通常情况下,在一个线程调用 run() 方法(在 Runnable 开启的线程),在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用,那么在 第二行 的 active 值为 false 时循环不会停止。但是以上代码中我们使用了 volatile 修饰 active,所以该循环会停止。
8.
Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),和字节型(byte)等类型。
>>> | 按位右移补零操作符。 |
9.
后缀 | () [] . (点操作符) | 左到右 |
一元 | expr++ expr-- | 从左到右 |
一元 | ++expr --expr + - ~ ! | 从右到左 |
乘性 | * /% | 左到右 |
加性 | + - | 左到右 |
移位 | >> >>> << | 左到右 |
关系 | > >= < <= | 左到右 |
相等 | == != | 左到右 |
按位与 | & | 左到右 |
按位异或 | ^ | 左到右 |
按位或 | | | 左到右 |
逻辑与 | && | 左到右 |
逻辑或 | | | | 左到右 |
条件 | ?: | 从右到左 |
赋值 | = + = - = * = / =%= >> = << =&= ^ = | = | 从右到左 |
逗号 | , | 左到右 |
10.
for(int x : numbers ){ System.out.print( x ); System.out.print(","); }
11.
包装类 | 基本数据类型 |
---|---|
Boolean | boolean |
Byte | byte |
Short | short |
Integer | int |
Long | long |
Character | char |
Float | float |
Double | double |
12.
Number & Math 类方法
下面的表中列出的是 Number & Math 类常用的一些方法:
序号 | 方法与描述 | |
---|---|---|
1 | xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。 | Integer x = 5; // 返回 byte 原生数据类型 System.out.println( x.byteValue() ); |
2 | compareTo() 将number对象与参数比较。 | Integer x = 5; System.out.println(x.compareTo(3)); 1 |
3 | equals() 判断number对象是否与参数相等。 | Integer x = 5; System.out.println(x.equals(y)); false |
4 | valueOf() 返回一个 Number 对象指定的内置数据类型 | Integer b = Integer.valueOf("444",16); // 使用 16 进制 |
5 | toString() 以字符串形式返回值。 | Integer x = 5; System.out.println(x.toString()); 5 |
6 | parseInt() 将字符串解析为int类型。 | int x =Integer.parseInt("9"); System.out.println(x);9 |
7 | abs() 返回参数的绝对值。 | Math.abs(a) |
8 | ceil() 返回大于等于( >= )给定参数的的最小整数,类型为双精度浮点型。 | Math.ceil(d) |
9 | floor() 返回小于等于(<=)给定参数的最大整数 。 | Math.floor(f) |
10 | rint() 返回与参数最接近的整数。返回类型为double。 | Math.rint(d) |
11 | round() 它表示四舍五入,算法为 Math.floor(x+0.5),即将原来的数字加上 0.5 后再向下取整,所以,Math.round(11.5) 的结果为12,Math.round(-11.5) 的结果为-11。 | Math.round(d) |
12 | min() 返回两个参数中的最小值。 | Math.min(12.123, 12.456)同类型 |
13 | max() 返回两个参数中的最大值。 | |
14 | exp() 返回自然数底数e的参数次方。 | double exp(double d) Math.E=2.7183 |
15 | log() 返回参数的自然数底数的对数值。 | double log(double d) |
16 | pow() 返回第一个参数的第二个参数次方。 | Math.pow(x, y) |
17 | sqrt() 求参数的算术平方根。 | Math.sqrt(x) |
18 | sin() 求指定double类型参数的正弦值。 | double degrees = 45.0; Math.toRadians(degrees); Math.sin(double d) Math.PI=3.1416 |
19 | cos() 求指定double类型参数的余弦值。 | |
20 | tan() 求指定double类型参数的正切值。 | |
21 | asin() 求指定double类型参数的反正弦值。 | Math.toDegrees() Math.asin() |
22 | acos() 求指定double类型参数的反余弦值。 | |
23 | atan() 求指定double类型参数的反正切值。 | |
24 | atan2() 将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。 | double x = 45.0; double y = 30.0; System.out.println( Math.atan2(x, y) ); |
25 | toDegrees() 将参数转化为角度。 | |
26 | toRadians() 将角度转换为弧度。 | |
27 | random() 返回一个随机数。 | import java.util.Random; Random rand=new Random(); int i=(int)(Math.random()*100); // 生成0-100的随机数,包括0不包括100 -- [0,100) int j=rand.nextInt(100); // 这里是一个方法的重载,参数的内容是指定范围 |
13.
Character 方法
下面是Character类的方法:
序号 | 方法与描述 | |
---|---|---|
1 | isLetter() 是否是一个字母 | Character.isLetter('c') |
2 | isDigit() 是否是一个数字字符 | Character.isDigit('5') |
3 | isWhitespace() 是否是一个空白字符 | Character.isWhitespace(' ') |
4 | isUpperCase() 是否是大写字母 | Character.isUpperCase('C') |
5 | isLowerCase() 是否是小写字母 | |
6 | toUpperCase() 指定字母的大写形式 | Character.toUpperCase('a') |
7 | toLowerCase() 指定字母的小写形式 | |
8 | toString() 返回字符的字符串形式,字符串的长度仅为1 | Character.toString('A') |
14.
可以用字符数组初始化字符串
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'}; String helloString = new String(helloArray);
String 方法
下面是 String 类支持的方法,更多详细,参看 Java String API 文档:
SN(序号) | 方法描述 | |
---|---|---|
1 | char charAt(int index) 返回指定索引处的 char 值。 | s.charAt(6) |
2 | int compareTo(Object o) 把这个字符串和另一个对象比较。 | 如果第一个字符和参数的第一个字符不等,结束比较,返回第一个字符的ASCII码差值。 如果第一个字符和参数的第一个字符相等,则以第二个字符和参数的第二个字符做比较,以此类推,直至不等为止,返回该字符的ASCII码差值。 如果两个字符串不一样长,可对应字符又完全一样,则返回两个字符串的长度差值。 |
3 | int compareTo(String anotherString) 按字典顺序比较两个字符串。 | |
4 | int compareToIgnoreCase(String str) 按字典顺序比较两个字符串,不考虑大小写。 | |
5 | String concat(String str) 将指定字符串连接到此字符串的结尾。 | s = s.concat("www.runoob.com"); |
6 | boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真。 | s.contentEquals(StringBuffer sb) |
7 | static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。 | Str2 = String.copyValueOf( Str1 ); |
8 | static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。 | Str2 = String.copyValueOf( Str1, 2, 6 ); |
9 | boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。 | retVal = Str.endsWith( "runoob" ); |
10 | boolean equals(Object anObject) 将此字符串与指定的对象比较。 | 使用 == 和 equals() 比较字符串。 String 中 == 比较引用地址是否相同,equals() 比较字符串的内容是否相同: |
11 | boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较,不考虑大小写。 | |
12 | byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。 | Str2 = Str1.getBytes(); |
13 | byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。 | Str2 = Str1.getBytes( "UTF-8" ); |
14 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组。 | Str1.getChars(4, 10, Str2, 0); |
15 | int hashCode() 返回此字符串的哈希码。 | Str.hashCode() |
16 | int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。 | string.indexOf("b") |
17 | int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。 | string.indexOf("a",3) |
18 | int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。 | Str.indexOf( SubStr1 ) |
19 | int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始。 | Str.indexOf( SubStr1, 15 ) |
20 | String intern() 返回字符串对象的规范化表示形式。 | Str2.intern()没变化输出,尽管在输出中调用intern方法并没有什么效果,但是实际上后台这个方法会做一系列的动作和操作。在调用”ab”.intern()方法的时候会返回”ab”,但是这个方法会首先检查字符串池中是否有”ab”这个字符串,如果存在则返回这个字符串的引用,否则就将这个字符串添加到字符串池中,然会返回这个字符串的引用。 |
21 | int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。 | 类似indexOf() |
22 | int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。 | |
23 | int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。 | |
24 | int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。 | |
25 | int length() 返回此字符串的长度。 | s.length() |
26 | boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。 | Str.matches("(.*)runoob(.*)") |
27 | boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。 | ignoreCase -- 如果为 true,则比较字符时忽略大小写。 toffset -- 此字符串中子区域的起始偏移量。 other -- 字符串参数。 ooffset -- 字符串参数中子区域的起始偏移量。 len -- 要比较的字符数 Str1.regionMatches(4, Str2, 0, 5) |
28 | boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等。 | |
29 | String replace(char oldChar, char newChar) 返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。 | Str.replace('o', 'T') |
30 | String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。 | Str.replaceAll("(.*)google(.*)", "runoob" ) |
31 | String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。 | |
32 | String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。 | |
33 | String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。 | limit -- 分割的份数。str.split("-",2) |
34 | boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。 | |
35 | boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。 | toffset --原字符串中开始查找的位置。Str.startsWith("runoob", 4) |
36 | CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列,它是此序列的一个子序列。 | beginIndex -- 起始索引(包括)。 endIndex -- 结束索引(不包括) Str.subSequence(4, 10) |
37 | String substring(int beginIndex) 返回一个新的字符串,它是此字符串的一个子字符串。 | |
38 | String substring(int beginIndex, int endIndex) 返回一个新字符串,它是此字符串的一个子字符串。 | Str.toCharArray() |
39 | char[] toCharArray() 将此字符串转换为一个新的字符数组。 | |
40 | String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。 | |
41 | String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。 | |
42 | String toString() 返回此对象本身(它已经是一个字符串!)。 | |
43 | String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。 | |
44 | String toUpperCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。 | |
45 | String trim() 返回字符串的副本,忽略前导空白和尾部空白。 | |
46 | static String valueOf(primitive data type x) 返回给定data type类型x参数的字符串表示形式。 | String.valueOf(d) |
47 | contains(CharSequence chars) 判断是否包含指定的字符系列。 | myStr.contains("Run" |
48 | isEmpty() 判断字符串是否为空。 |
15.
在使用 StringBuffer 类时,每次都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,所以如果需要对字符串进行修改推荐使用 StringBuffer。
StringBuilder 类在 Java 5 中被提出,它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的(不能同步访问)。
由于 StringBuilder 相较于 StringBuffer 有速度优势,所以多数情况下建议使用 StringBuilder 类。
StringBuffer 方法
以下是 StringBuffer 类支持的主要方法:
序号 | 方法描述 | |
---|---|---|
1 | public StringBuffer append(String s) 将指定的字符串追加到此字符序列。 | sBuffer.append("www"); |
2 | public StringBuffer reverse() 将此字符序列用其反转形式取代。 | sb.reverse() |
3 | public delete(int start, int end) 移除此序列的子字符串中的字符。 | sb.delete(5,8)依然是不包括end |
4 | public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。 | sb.insert(4,5)在位置4插入5 |
5 | insert(int offset, String str) 将 str 参数的字符串插入此序列中。 | sb.insert(4,"Java") |
6 | replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。 |
以下列表列出了 StringBuffer 类的其他常用方法:
序号 | 方法描述 | |
---|---|---|
1 | int capacity() 返回当前容量。 | |
2 | char charAt(int index) 返回此序列中指定索引处的 char 值。 | |
3 | void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。 | 如果minimumCapacity参数>旧容量的两倍加2,则新容量等于minimumCapacity,否则新容量等于旧容量的两倍加2。 |
4 | void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst 。 | sb.getChars(4, 10, Str, 0); |
5 | int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。 | |
6 | int indexOf(String str, int fromIndex) 从指定的索引处开始,返回第一次出现的指定子字符串在该字符串中的索引。 | |
7 | int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。 | |
8 | int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。 | str.indexOf("For", 3) fromIndex是原buffer的起始查找位置 |
9 | int length() 返回长度(字符数)。 | |
10 | void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch 。 | |
11 | void setLength(int newLength) 设置字符序列的长度。 | 设置新长度 |
12 | CharSequence subSequence(int start, int end) 返回一个新的字符序列,该字符序列是此序列的子序列。 | CharSequence cs = st_b.subSequence(0, 4) |
13 | String substring(int start) 返回一个新的 String ,它包含此字符序列当前所包含的字符子序列。 | |
14 | String substring(int start, int end) 返回一个新的 String ,它包含此序列当前所包含的字符子序列。 | |
15 | String toString() 返回此序列中数据的字符串表示形式。 |
16.
数组
double[] myList = new double[10];
double[] myList = {1.9, 2.9, 3.4, 3.5};
作为函数参数 printArray(int[] array);作为函数返回值int[] reverse(int[] list)
序号 | 方法和说明 | |
---|---|---|
1 | public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。 | Arrays.binarySearch(array1, 3) |
2 | public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。 | Arrays.equals(array, array1) |
3 | public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。 | Arrays.fill(array, 5) Arrays.fill(array, 2, 4, 8);2、3填充8 |
4 | public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。 | Arrays.sort(array1, 2, 7)对数组的第2个到第6个元素进行排序 |
17.
Java Date()
序号 | 方法和描述 | |
---|---|---|
1 | boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。 | Date1.after(Date2),当Date1大于Date2时,返回TRUE,当小于等于时,返回false; |
2 | boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。 | Date1.before(Date2),当Date1小于Date2时,返回TRUE,当大于等于时,返回false; |
3 | Object clone( ) 返回此对象的副本。 | date.clone() |
4 | int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。 | |
5 | int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。 | |
6 | boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。 | |
7 | long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 | this_date.getTime() |
8 | int hashCode( ) 返回此对象的哈希码值。 | |
9 | void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。 | dateOne.setTime(1000) |
10 | String toString( ) 把此 Date 对象转换为以下形式的 String: dow mon dd hh:mm:ss zzz yyyy 其中: dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。 | Mon May 04 09:51:52 CDT 2013 |
18.
SimpleDateFormat的使用
Date dNow = new Date( );
SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
System.out.println("当前时间为: " + ft.format(dNow));
19.
日期和时间的格式化编码
时间模式字符串用来指定时间格式。在此模式中,所有的 ASCII 字母被保留为模式字母,定义如下:
字母 | 描述 | 示例 |
---|---|---|
G | 纪元标记 | AD |
y | 四位年份 | 2001 |
M | 月份 | July or 07 |
d | 一个月的日期 | 10 |
h | A.M./P.M. (1~12)格式小时 | 12 |
H | 一天中的小时 (0~23) | 22 |
m | 分钟数 | 30 |
s | 秒数 | 55 |
S | 毫秒数 | 234 |
E | 星期几 | Tuesday |
D | 一年中的日子 | 360 |
F | 一个月中第几周的周几 | 2 (second Wed. in July) |
w | 一年中第几周 | 40 |
W | 一个月中第几周 | 1 |
a | A.M./P.M. 标记 | PM |
k | 一天中的小时(1~24) | 24 |
K | A.M./P.M. (0~11)格式小时 | 10 |
z | 时区 | Eastern Standard Time |
20.
使用printf格式化日期
printf 方法可以很轻松地格式化时间和日期。使用两个字母格式,它以 %t 开头并且以下面表格中的一个字母结尾。
转 换 符 | 说 明 | 示 例 |
---|---|---|
c | 包括全部日期和时间信息 | 星期六 十月 27 14:21:20 CST 2007 |
F | "年-月-日"格式 | 2007-10-27 |
D | "月/日/年"格式 | 10/27/07 |
r | "HH:MM:SS PM"格式(12时制) | 02:25:51 下午 |
T | "HH:MM:SS"格式(24时制) | 14:28:16 |
R | "HH:MM"格式(24时制) | 14:28 |
示例
Date date = new Date();
System.out.printf("全部日期和时间信息:%tc%n",date); //c的使用
想以利用一个格式化字符串指出要被格式化的参数的索引。
索引必须紧跟在%后面,而且必须以$结束。例如:
System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date);
输出:Due date: January 12, 2022
或者,你可以使用 < 标志。它表明先前被格式化的参数要被再次使用。例如:
System.out.printf("%s %tB %<te, %<tY", "Due date:", date);
21.
休眠:Thread.sleep(1000*3);
测量时间:long start = System.currentTimeMillis( );不同代码位置获得的时刻不同
22.
Calendar类
//创建一个代表2009年6月12日的Calendar对象
Calendar c1 = Calendar.getInstance();//默认是当前日期
c1.set(2009, 6 - 1, 12);
public final void set(int year,int month,int date)
public void set(int field,int value)
c1.set(Calendar.DATE,10);
c1.set(Calendar.DATE,10);//表示为10天后的日期
c1.get(Calendar.YEAR)
Calendar类对象字段类型
Calendar类中用以下这些常量表示不同的意义,jdk内的很多类其实都是采用的这种思想
常量 | 描述 |
---|---|
Calendar.YEAR | 年份 |
Calendar.MONTH | 月份 |
Calendar.DATE | 日期 |
Calendar.DAY_OF_MONTH | 日期,和上面的字段意义完全相同 |
Calendar.HOUR | 12小时制的小时 |
Calendar.HOUR_OF_DAY | 24小时制的小时 |
Calendar.MINUTE | 分钟 |
Calendar.SECOND | 秒 |
Calendar.DAY_OF_WEEK | 星期几 |
23.
Java 正则表达式
捕获组
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
public static void main( String[] args ){
// 按指定模式在字符串查找
String line = "This order was placed for QT3000! OK?";
String pattern = "(\\D*)(\\d+)(.*)";
// 创建 Pattern 对象
Pattern r = Pattern.compile(pattern);
// 现在创建 matcher 对象
Matcher m = r.matcher(line);
if (m.find( )) {
System.out.println("Found value: " + m.group(0) );
System.out.println("Found value: " + m.group(1) );
System.out.println("Found value: " + m.group(2) );
System.out.println("Found value: " + m.group(3) );
} else {
System.out.println("NO MATCH");
}
}
}
Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT
Found value: 3000
Found value: ! OK?
start 和 end 方法
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static final String REGEX = "\\bcat\\b";
private static final String INPUT =
"cat cat cat cattie cat";
public static void main( String[] args ){
Pattern p = Pattern.compile(REGEX);
Matcher m = p.matcher(INPUT); // 获取 matcher 对象
int count = 0;
while(m.find()) {
count++;
System.out.println("Match number "+count);
System.out.println("start(): "+m.start());
System.out.println("end(): "+m.end());
}
}
}
Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22
matches 和 lookingAt 方法
matches 和 lookingAt 方法都用来尝试匹配一个输入序列模式。它们的不同是 matches 要求整个序列都匹配,而lookingAt 不要求。
replaceFirst 和 replaceAll 方法
replaceFirst 和 replaceAll 方法用来替换匹配正则表达式的文本。不同的是,replaceFirst 替换首次匹配,replaceAll 替换所有匹配。
appendReplacement 和 appendTail 方法
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches
{
private static String REGEX = "a*b";
private static String INPUT = "aabfooaabfooabfoobkkk";
private static String REPLACE = "-";
public static void main(String[] args) {
Pattern p = Pattern.compile(REGEX);
// 获取 matcher 对象
Matcher m = p.matcher(INPUT);
StringBuffer sb = new StringBuffer();
while(m.find()){
m.appendReplacement(sb,REPLACE);
}
m.appendTail(sb);
System.out.println(sb.toString());
}
}
-foo-foo-foo-kkk
24.
可变参数方法 public static void printMax( double... numbers)
//finalize()它在对象被垃圾收集器析构(回收)之前调用,这个方法叫做 finalize( ),它用来清除回收对象
protected void finalize() throws java.lang.Throwable {
super.finalize();
System.out.println("Cake Object " + id + "is disposed");
}
25.
BufferedReader read()一个字符 readline()一行字符
//使用 BufferedReader 在控制台读取字符
import java.io.*;
public class BRRead {
public static void main(String[] args) throws IOException {
char c;
String str;
// 使用 System.in 创建 BufferedReader
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("输入字符, 按下 'q' 键退出。");
// 读取字符
do {
c = (char) br.read();
System.out.println(c);
str = br.readLine();
System.out.println(str);
} while (c != 'q');
}
}
void write(int byteval) 控制台输出一个字符
InputStream f = new FileInputStream("C:/java/hello");
序号 | 方法及描述 |
---|---|
1 | public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。 |
2 | protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。 |
3 | public int read(int r)throws IOException{} 这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据,如果已经到结尾则返回-1。 |
4 | public int read(byte[] r) throws IOException{} 这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。 |
5 | public int available() throws IOException{} 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。 |
ByteArrayInputStream bArray = new ByteArrayInputStream(byte [] a);
ByteArrayInputStream bArray = new ByteArrayInputStream(byte []a, int off, int len)
序号 | 方法描述 |
---|---|
1 | public int read() 从此输入流中读取下一个数据字节。 |
2 | public int read(byte[] r, int off, int len) 将最多 len 个数据字节从此输入流读入字节数组。 |
3 | public int available() 返回可不发生阻塞地从此输入流读取的字节数。 |
4 | public void mark(int read) 设置流中的当前标记位置。 |
5 | public long skip(long n) |
DataInputStream dis = new DataInputStream(InputStream in);
序号 | 方法描述 |
---|---|
1 | public final int read(byte[] r, int off, int len)throws IOException 从所包含的输入流中将 len 个字节读入一个字节数组中。如果len为-1,则返回已读字节数。 |
2 | Public final int read(byte [] b)throws IOException 从所包含的输入流中读取一定数量的字节,并将它们存储到缓冲区数组 b 中。 |
3 |
|
4 | public String readLine() throws IOException 从输入流中读取下一文本行。 |
OutputStream f = new FileOutputStream("C:/java/hello")
序号 | 方法及描述 |
---|---|
1 | public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。 |
2 | protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。 |
3 | public void write(int w)throws IOException{} 这个方法把指定的字节写到输出流中。 |
4 | public void write(byte[] w) 把指定数组中w.length长度的字节写到OutputStream中 |
ByteArrayOutputStream
序号 | 方法描述 |
---|---|
1 | public void reset() 将此字节数组输出流的 count 字段重置为零,从而丢弃输出流中目前已累积的所有数据输出。 |
2 | public byte[] toByteArray() 创建一个新分配的字节数组。数组的大小和当前输出流的大小,内容是当前输出流的拷贝。 |
3 | public String toString() 将缓冲区的内容转换为字符串,根据平台的默认字符编码将字节转换成字符。 |
4 | public void write(int w) 将指定的字节写入此字节数组输出流。bOutput.write(System.in.read()); |
5 | public void write(byte []b, int off, int len) 将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。 |
6 | public void writeTo(OutputStream outSt) 将此字节数组输出流的全部内容写入到指定的输出流参数中。 |
DataOutputStream
序号 | 方法描述 |
---|---|
1 | public final void write(byte[] w, int off, int len)throws IOException 将指定字节数组中从偏移量 off 开始的 len 个字节写入此字节数组输出流。 |
2 | Public final int write(byte [] b)throws IOException 将指定的字节写入此字节数组输出流。 |
3 |
|
4 | Public void flush()throws IOException 刷新此输出流并强制写出所有缓冲的输出字节。 |
5 | public final void writeBytes(String s) throws IOException 将字符串以字节序列写入到底层的输出流,字符串中每个字符都按顺序写入,并丢弃其高八位。 |
26.
File d = new File(dirname); // 现在创建目录 d.mkdirs();
mkdirs()方法创建一个文件夹和它的所有父文件夹。
读取目录
import java.io.File;
public class DirList {
public static void main(String args[]) {
String dirname = "/tmp";
File f1 = new File(dirname);
if (f1.isDirectory()) {
System.out.println("目录 " + dirname);
String s[] = f1.list();
for (int i = 0; i < s.length; i++) {
File f = new File(dirname + "/" + s[i]);
if (f.isDirectory()) {
System.out.println(s[i] + " 是一个目录");
} else {
System.out.println(s[i] + " 是一个文件");
}
}
} else {
System.out.println(dirname + " 不是一个目录");
}
}
}
删除目录或文件
import java.io.File;
public class DeleteFileDemo {
public static void main(String[] args) {
// 这里修改为自己的测试目录
File folder = new File("/tmp/java/");
deleteFolder(folder);
}
// 删除文件及目录
public static void deleteFolder(File folder) {
File[] files = folder.listFiles();
if (files != null) {
for (File f : files) {
if (f.isDirectory()) {
deleteFolder(f);
} else {
f.delete();
}
}
}
folder.delete();
}
}
27.
Scanner s = new Scanner(System.in);
if (scan.hasNext()) { String str1 = scan.next();
if (scan.hasNextLine()) { String str2 = scan.nextLine();
next() 与 nextLine() 区别
next():
- 1、一定要读取到有效字符后才可以结束输入。
- 2、对输入有效字符之前遇到的空白,next() 方法会自动将其去掉。
- 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
- next() 不能得到带有空格的字符串。
nextLine():
- 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
- 2、可以获得空白。
28.
异常
异常方法
下面的列表是 Throwable 类的主要方法:
序号 | 方法及说明 |
---|---|
1 | public String getMessage() 返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。 |
2 | public Throwable getCause() 返回一个 Throwable 对象代表异常原因。 |
3 | public String toString() 返回此 Throwable 的简短描述。 |
4 | public void printStackTrace() 将此 Throwable 及其回溯打印到标准错误流。。 |
5 | public StackTraceElement [] getStackTrace() 返回一个包含堆栈层次的数组。下标为0的元素代表栈顶,最后一个元素代表方法调用堆栈的栈底。 |
6 | public Throwable fillInStackTrace() 用当前的调用栈层次填充Throwable 对象栈层次,添加到栈层次任何先前信息中。 |
声明自定义异常
class MyException extends Exception{ }
通用异常
在Java中定义了两种类型的异常和错误。
- JVM(Java虚拟机) 异常:由 JVM 抛出的异常或错误。例如:NullPointerException 类,ArrayIndexOutOfBoundsException 类,ClassCastException 类。
- 程序级异常:由程序或者API程序抛出的异常。例如 IllegalArgumentException 类,IllegalStateException 类。
29.
父类和子类这样会编译错误
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
System.out.println("狗可以跑和走");
}
public void bark(){
System.out.println("狗可以吠叫");
}
}
public class TestDog{
public static void main(String args[]){
Animal a = new Animal(); // Animal 对象
Animal b = new Dog(); // Dog 对象
a.move();// 执行 Animal 类的方法
b.move();//执行 Dog 类的方法
b.bark();
}
}
方法的重写规则
-
参数列表与被重写方法的参数列表必须完全相同。
-
返回类型与被重写方法的返回类型可以不相同,但是必须是父类返回值的派生类(java5 及更早版本返回类型要一样,java7 及更高版本可以不同)。
-
访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为 public,那么在子类中重写该方法就不能声明为 protected。
-
父类的成员方法只能被它的子类重写。
-
声明为 final 的方法不能被重写。
-
声明为 static 的方法不能被重写,但是能够被再次声明。
-
子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为 private 和 final 的方法。
-
子类和父类不在同一个包中,那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
-
重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以。
-
构造方法不能被重写。
-
如果不能继承一个类,则不能重写该类的方法。
重载规则:
- 被重载的方法必须改变参数列表(参数个数或类型不一样);
- 被重载的方法可以改变返回类型;
- 被重载的方法可以改变访问修饰符;
- 被重载的方法可以声明新的或更广的检查异常;
- 方法能够在同一个类中或者在一个子类中被重载。
- 无法以返回值类型作为重载函数的区分标准。
多态的优点
- 1. 消除类型之间的耦合关系
- 2. 可替换性
- 3. 可扩充性
- 4. 接口性
- 5. 灵活性
- 6. 简化性
多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象:Parent p = new Child();
虚函数的存在是为了多态。
Java 中其实没有虚函数的概念,它的普通函数就相当于 C++ 的虚函数,动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性,可以加上 final 关键字变成非虚函数。
抽象类总结规定
-
1. 抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译无法通过。只有抽象类的非抽象子类可以创建对象。
-
2. 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
-
3. 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。
-
4. 构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。
-
5. 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。
接口与类的区别:
- 接口不能用于实例化对象。
- 接口没有构造方法。
- 接口中所有的方法必须是抽象方法,Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
- 接口不能包含成员变量,除了 static 和 final 变量。
- 接口不是被类继承了,而是要被类实现。
- 接口支持多继承。
标记接口是没有任何方法和属性的接口.
包通常使用小写的字母来命名避免与类、接口名字的冲突。
30.
Java Enumeration接口
序号 | 方法描述 |
---|---|
1 | boolean hasMoreElements( ) 测试此枚举是否包含更多的元素。 |
2 | Object nextElement( ) 如果此枚举对象至少还有一个可提供的元素,则返回此枚举的下一个元素。 |
实例
import java.util.Vector;
import java.util.Enumeration;
public class EnumerationTester {
public static void main(String args[]) {
Enumeration<String> days;
Vector<String> dayNames = new Vector<String>();
dayNames.add("Sunday");
dayNames.add("Monday");
dayNames.add("Tuesday");
dayNames.add("Wednesday");
dayNames.add("Thursday");
dayNames.add("Friday");
dayNames.add("Saturday");
days = dayNames.elements();
while (days.hasMoreElements()){
System.out.println(days.nextElement());
}
}
}
Java Bitset类
实例
import java.util.BitSet;
public class BitSetDemo {
public static void main(String args[]) {
BitSet bits1 = new BitSet(16);
BitSet bits2 = new BitSet(16);
// set some bits
for(int i=0; i<16; i++) {
if((i%2) == 0) bits1.set(i);
if((i%5) != 0) bits2.set(i);
}
System.out.println("Initial pattern in bits1: ");
System.out.println(bits1);
System.out.println("\nInitial pattern in bits2: ");
System.out.println(bits2);
// AND bits
bits2.and(bits1);
System.out.println("\nbits2 AND bits1: ");
System.out.println(bits2);
// OR bits
bits2.or(bits1);
System.out.println("\nbits2 OR bits1: ");
System.out.println(bits2);
// XOR bits
bits2.xor(bits1);
System.out.println("\nbits2 XOR bits1: ");
System.out.println(bits2);
}
}
Initial pattern in bits1:
{0, 2, 4, 6, 8, 10, 12, 14}
Initial pattern in bits2:
{1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}
bits2 AND bits1:
{2, 4, 6, 8, 12, 14}
bits2 OR bits1:
{0, 2, 4, 6, 8, 10, 12, 14}
bits2 XOR bits1:
{}
Java Vector 类
第一种构造方法创建一个默认的向量,默认大小为 10:
Vector()
第二种构造方法创建指定大小的向量。
Vector(int size)
第三种构造方法创建指定大小的向量,并且增量用 incr 指定。增量表示向量每次增加的元素数目。
Vector(int size,int incr)
第四种构造方法创建一个包含集合 c 元素的向量:
Vector(Collection c)
Java Stack 类
序号 | 方法描述 |
---|---|
1 | boolean empty() 测试堆栈是否为空。 |
2 | Object peek( ) 查看堆栈顶部的对象,但不从堆栈中移除它。 |
3 | Object pop( ) 移除堆栈顶部的对象,并作为此函数的值返回该对象。 |
4 | Object push(Object element) 把项压入堆栈顶部。 |
5 | int search(Object element) 返回对象在堆栈中的位置,以 1 为基数。 |
Java Dictionary 类
序号 | 方法描述 |
1 | Enumeration elements( ) 返回此 dictionary 中值的枚举。 |
2 | Object get(Object key) 返回此 dictionary 中该键所映射到的值。 |
3 | boolean isEmpty( ) 测试此 dictionary 是否不存在从键到值的映射。 |
4 | Enumeration keys( ) 返回此 dictionary 中的键的枚举。 |
5 | Object put(Object key, Object value) 将指定 key 映射到此 dictionary 中指定 value。 |
6 | Object remove(Object key) 从此 dictionary 中移除 key (及其相应的 value)。 |
7 | int size( ) 返回此 dictionary 中条目(不同键)的数量。 |
Java Hashtable 类
String toString( )
返回此 Hashtable 对象的字符串表示形式,其形式为 ASCII 字符 ", " (逗号加空格)分隔开的、括在括号中的一组条目。
Java Properties 类
Properties 继承于 Hashtable。表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。
31.
Set和List的区别
-
1. Set 接口实例存储的是无序的,不重复的数据。List 接口实例存储的是有序的,可以重复的元素。
-
2. Set检索效率低下,删除和插入效率高,插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
-
3. List和数组类似,可以动态增长,根据实际存储的数据的长度自动增长List的长度。查找元素效率高,插入删除效率低,因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。
LinkedList
该类实现了List接口,允许有null(空)元素。主要用于创建链表数据结构,该类没有同步方法,如果多个线程同时访问一个List,则必须自己实现访问同步,解决方法就是在创建List时候构造一个同步的List。例如:
List list=Collections.synchronizedList(newLinkedList(...));
LinkedList 查找效率低。
ArrayList
该类也是实现了List的接口,实现了可变大小的数组,随机访问和遍历元素时,提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%,插入删除效率低。
遍历map
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
while (it.hasNext())
{ Map.Entry<String, String> entry = it.next();
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue()); }
for (Map.Entry<String, String> entry : map.entrySet()) { System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue()); }
基本类型 | 引用类型 |
---|---|
boolean | Boolean |
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
泛型方法
public static < E > void printArray( E[] inputArray )
{
// 输出数组元素
for ( E element : inputArray ){
System.out.printf( "%s ", element );
}
System.out.println();
}
泛型类
public class Box<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("菜鸟教程"));
System.out.printf("整型值为 :%d\n\n", integerBox.get());
System.out.printf("字符串为 :%s\n", stringBox.get());
}
}
类型通配符一般是使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String>,List<Integer> 等所有 List<具体类型实参> 的父类。List<? extends Number>
Java 序列化
public class Employee implements java.io.Serializable
注意: 当序列化一个对象到文件时, 按照 Java 的标准约定是给文件一个 .ser 扩展名。
//序列化
try
{
FileOutputStream fileOut =
new FileOutputStream("/tmp/employee.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();
System.out.printf("Serialized data is saved in /tmp/employee.ser");
}catch(IOException i)
{
i.printStackTrace();
}
//反序列化
try
{
FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
32.
Socket 客户端实例
import java.net.*;
import java.io.*;
public class GreetingClient
{
public static void main(String [] args)
{
String serverName = args[0];
int port = Integer.parseInt(args[1]);
try
{
System.out.println("连接到主机:" + serverName + " ,端口号:" + port);
Socket client = new Socket(serverName, port);
System.out.println("远程主机地址:" + client.getRemoteSocketAddress());
OutputStream outToServer = client.getOutputStream();
DataOutputStream out = new DataOutputStream(outToServer);
out.writeUTF("Hello from " + client.getLocalSocketAddress());
InputStream inFromServer = client.getInputStream();
DataInputStream in = new DataInputStream(inFromServer);
System.out.println("服务器响应: " + in.readUTF());
client.close();
}catch(IOException e)
{
e.printStackTrace();
}
}
}
Socket 服务端实例
import java.net.*;
import java.io.*;
public class GreetingServer extends Thread
{
private ServerSocket serverSocket;
public GreetingServer(int port) throws IOException
{
serverSocket = new ServerSocket(port);
serverSocket.setSoTimeout(10000);
}
public void run()
{
while(true)
{
try
{
System.out.println("等待远程连接,端口号为:" + serverSocket.getLocalPort() + "...");
Socket server = serverSocket.accept();
System.out.println("远程主机地址:" + server.getRemoteSocketAddress());
DataInputStream in = new DataInputStream(server.getInputStream());
System.out.println(in.readUTF());
DataOutputStream out = new DataOutputStream(server.getOutputStream());
out.writeUTF("谢谢连接我:" + server.getLocalSocketAddress() + "\nGoodbye!");
server.close();
}catch(SocketTimeoutException s)
{
System.out.println("Socket timed out!");
break;
}catch(IOException e)
{
e.printStackTrace();
break;
}
}
}
public static void main(String [] args)
{
int port = Integer.parseInt(args[0]);
try
{
Thread t = new GreetingServer(port);
t.run();
}catch(IOException e)
{
e.printStackTrace();
}
}
}
33.
一个线程的生命周期
创建一个线程
Java 提供了三种创建线程的方法:
- 通过实现 Runnable 接口;
- 通过继承 Thread 类本身;
- 通过 Callable 和 Future 创建线程。
34.
"Hello, World" Applet:
import java.applet.*;
import java.awt.*;
public class HelloWorldApplet extends Applet
{
public void paint (Graphics g)
{
g.drawString ("Hello World", 25, 50);
}
}
Applet 的调用
<html>
<title>The Hello, World Applet</title>
<hr>
<applet code="HelloWorldApplet.class" width="320" height="120">
If your browser was Java-enabled, a "Hello, World"
message would appear here.
</applet>
<hr>
</html>
Viewer 或者浏览器在文档的位置寻找编译过的 Java 代码,要指定文档的路径,得使用 <applet> 标签的 codebase 属性指定。
如下所示:
<applet codebase="http://amrood.com/applets" code="HelloWorldApplet.class" width="320" height="120">
如果 Applet 所在一个包中而不是默认包,那么所在的包必须在 code 属性里指定,例如:
<applet code="mypackage.subpackage.TestApplet.class" width="320" height="120">
显示图片
Applet 能显示 GIF,JPEG,BMP 等其他格式的图片。为了在 Applet 中显示图片,你需要使用 java.awt.Graphics 类的drawImage()方法。
如下实例演示了显示图片的所有步骤:
ImageDemo.java 文件代码:
import java.applet.*;
import java.awt.*;
import java.net.*;
public class ImageDemo extends Applet
{
private Image image;
private AppletContext context;
public void init()
{
context = this.getAppletContext();
String imageURL = this.getParameter("image");
if(imageURL == null)
{
imageURL = "java.jpg";
}
try
{
URL url = new URL(this.getDocumentBase(), imageURL);
image = context.getImage(url);
}catch(MalformedURLException e)
{
e.printStackTrace();
// Display in browser status bar
context.showStatus("Could not load image!");
}
}
public void paint(Graphics g)
{
context.showStatus("Displaying image");
g.drawImage(image, 0, 0, 200, 84, null);
g.drawString("www.javalicense.com", 35, 100);
}
}