JAVA笔记
>个人博客:www.huangrd.top,欢迎访问学习更多知识。
五、继承与多态
5.1继承
实现代码的重用,提高程序的可维护性。
5.1.1继承的概念
5.1.2子类对象的创建
[修饰符] class 子类名 extends 父类名 class Cattle extends Animal{ }
5.1.3继承的使用原则
1.子类只能继承父类的protected和public;
2.子类能继承同一个包中默认修饰符修饰的成员变量和方法;
3.子类的成员变量如果与父类相同,则隐藏父类的成员变量;
4.子类的成员方法如果与父类相同,则覆盖父类的成员方法;
5.1.4关键字super
子类访问父类中被子类隐藏的成员变量、方法,使用关键字super
super的作用 //1.调用父类的构造方法 super([参数列表]); //2.操作被隐藏的成员变量和被覆盖的成员方法 super.成员变量名 super.成员方法名([参数列表])
5.2子类的继承
Java中,任何类都继承于 Object类,除Object类外,每个类只能有一个父类,但可以有多个子类。
1.同一包中的子类和父类
子类和父类在同一包中,则子类会继承父类中非private修饰的成员变量和方法。’
2.非同一包的子类与父类
子类和父类不在同一包时,子类不会继承父类中private和友好成员变量和方法。
5.3多态
在Java中,通过重载Overloading和覆盖Overriding实现类的多态性。
1.方法的重载
参数个数、参数类型不同来重载方法。
ps:方法的返回值类型不能用来重载。
2.避免歧义
3.方法的覆盖
当子类继承父类时,如果子类的方法名和父类方法名相同,则子类不能继承父类的成员方法。称为覆盖。
覆盖体现了子类补充或改变父类的能力。
ps:
-
子类不能覆盖父类声明为final或static的方法。
-
子类必须覆盖父类声明为abstract的方法,或者子类将该方法声明为abstract。
-
子类覆盖父类的方法时,子类方法的声明必须和父类方法的声明相同。
4.向上转型
取得一个对象的引用并将它看做超类类型的对象,成为向上转型。
public class Zoos { public void free(Animal animal){ animal.move(); } } abstract class Animal{//抽象类 public abstract void move();//移动方法 } class Parrot extends Animal{ public void move(){ System.out.println("鹦鹉正在飞"); } public static void main(String[] args) { Zoos zoos = new Zoos(); Parrot parrot = new Parrot(); Tortoise tortoise = new Tortoise(); zoos.free(parrot); zoos.free(tortoise); } } class Tortoise extends Animal{ public void move(){ System.out.println("乌龟正在爬"); } }
5.4抽象类
1.抽象类和抽象方法
-
抽象类,就是只声明方法的存在而不去实例化他的类。
-
抽象类不能实例化。
-
抽象类关键字abstract。
//语法格式如下 abstract class 类名{ 类体 }
抽象方法:
-
在抽象类中创建、没有实现、必须由子类重写的方法称为抽象方法。
-
抽象方法只有声明,没有实现。
-
抽象方法关键词abstract。
-
抽象方法不能用关键字private和static修饰。
//语法格式如下 abstract <方法返回值类型> 方法名 (参数列表)
2.抽象类和抽象方法的规则
-
抽象类和抽象方法必须使用abstract来修饰。
-
抽象类不能实例化,即使抽象类不含抽象方法也不能实例化。
-
抽象类可以包含属性、方法、构造器、初始化块、内部类和枚举类。抽象类中的构造器不能创建用例,主要用于被其子类调用。
-
含有抽象方法的类只能被定义为抽象类。
5.5关键字final
关键字final用来修饰类、变量和方法,表示他修饰的类、变量和方法不能改变。
1. final变量
final修饰变量,表示该变量一旦 获得初始值之后就不可以被改变。可以用来修饰成员变量、局部变量、形参。
2. final类
final修饰的类,该类不能被继承,不能有子类。
//语法格式如下 final class 类名{ 类体 }
3. final方法
final修饰的方法,表示该方法不能被重写。可用来禁止子类重写父类的方法。
5.6.内部类
在其他类内部定义的子类。
//eg public class Zoo{ class Wolf{//内部类 } }
1.成员内部类
成员内部类和成员变量一样,属于类的全局成员。
!!!成员内部类不可以使用public 修饰,每个Java类文件只允许使用一个public修饰的公共类(公共类名称必须与类文件同名)
2.局部内部类
和局部变量类似,在方法内定义,只在方法内部有效。
public void sell(){ class Apple{// 局部内部类 } }
3.静态内部类
和静态变量类似,使用static修饰。
public class Sample{ static class Apple{//静态内部类 } }
4.匿名内部类
没有名称的内部类,常被应用到Swing程序设计的事件监听。
特点:
匿名内部类可以继承父类方法,也可以重写父类方法;
匿名内部类可以访问外嵌类中的成员变量和方法,在匿名内部类中不能声明及港台变量和静态方法。
使用匿名内部类时,必须在某个类中直接使用匿名内部类创建对象。
使用匿名内部类创建对象时,需要直接使用父类的构造方法。
//一般格式如下 new ClassName(){ } //创建一个匿名的Apple类 public class Sample{ public static void main(String[] args){ new Apple(){ public void introduction(){ System.out.println("这是一个匿名对象"); } } }; }
匿名对象经常创建接口的唯一实现类,或者创建某个类的唯一子类。
interface Apple{//定义Apple接口 public void say();//定义say方法 } public class Sample {//创建Sample类 public static void print(Apple apple){//创建print()方法 apple.say(); } public static void main(String[] args) { Sample.print(new Apple() {//为print()方法传递参数 @Override public void say() {//实现Apple接口 System.out.println("这是一箱苹果");//匿名内部参数传递 } }); } }
六、接口
Java仅支持单继承,不支持多继承。为了解决这种问题,Java提供接口来实现类的多继承功能。
6.1接口简介
Java中接口是一个抽象的类,接口中的所有方法都没有方法体。
6.2接口的定义
Java使用关键字interface来定义一个接口。接口和类的定义类似,也分为接口的声明和接口体,接口体由常量定义和方法定义来实现。
//语法格式如下 [修饰符] interface 接口名 [extends 父类接口列表]{ [public] [static] [final] 常量; [public] [abstract] 方法; } //修饰符 public
接口类文件必须与接口名相同。
6.3借口的继承
接口可以有多个直接父类接口,继承时获得父类接口中定义的所有抽象方法、常量属性。
public interface interfaceC extands interfaceA,interfaceB{ }
6.4接口的实现
接口可以被类实现,也可以被其他接口继承。在类中实现接口使用关键字implements
//语法格式如下 [修饰符] class <类名> [extends 父类名] [implements 接口列表]{ } //修饰符 public final abstract
6.5接口与抽象类
共同点:
-
接口和抽象类都不能实例化,但都能被其他类实现和继承;
-
接口和抽象类都可以包含抽象方法,实现接口或者继承抽象类的普通子类必须包含这些抽象方法;
差别:
-
子类只能继承一个抽象类但可以实现多个接口;
-
一个类若要实现一个接口,则必须实现接口的所有抽象方法,而抽象类则不用;
-
抽象类的成员变量可以是各类型的,而接口只能是public、static、final类型的;
-
接口只能定义抽象方法,抽象类可以定义非抽象方法;
-
抽象类可以有静态方法和静态代码块,接口中不可以;
-
接口不能被实例化,没有构造方法,而抽象类可以有构造方法;
6.6接口的 UML 图
-
接口是Java的一种数据类型。
-
使用接口声明的变量称为接口变量。
-
接口变量是引用型的变量。
public interface People { void Say(String S); //定义一个接口 } public class Teacher implements People{ public void Say(String s){ //Teacher类实现接口 System.out.println(s); } } public class Student implements People{ public void Say(String s){ System.out.println(s); //Student类实现接口 } } public class App { public static void main(String[] args) { People p; //声明接口变量 p=new Teacher(); //接口变量中存放对象的引用 p.Say("我是老师"); //接口回调 p=new Student(); //接口变量中存放对象的引用 p.Say("我是学生"); //接口回调 } }
6.8接口与多态
6.9接口参数
public interface Eatfood { void Eatfood(); } public class Chinese implements Eatfood{ public void Eatfood(){ System.out.println("中国人用筷子吃饭"); } } public class America implements Eatfood{ public void Eatfood(){ System.out.println("美国人习惯用刀叉吃饭"); } } public class EatMethods { public void lookEatMethods(Eatfood eat){//定义接口类型的参数 eat.Eatfood(); //接口回调 } } public class Example2 { public static void main(String[] args) { EatMethods em=new EatMethods(); em.lookEatMethods(new Chinese()); em.lookEatMethods(new America()); } }
6.10面向接口编程
一种多态的体现。
七、异常处理
异常处理检查可能出现的错误,以保证程序的可读性和和维护性。在Java中,会将异常封装到一个类中,当出现错误时,就会抛出异常。
7.1异常的描述
程序运行时出现的错误被称为异常。
public class Baulk { public static void main(String[] args) { int result = 3 / 0; System.out.println(result); } }
7.2异常的分类
异常是Throwable类的子类。Throwable 类派生了两个子类,分别是Error类和Exception类。
1.系统错误———Error
描述Java运行时系统内部错误及资源耗尽错误。该类常规下不能捕获异常,如OutOfMemororyError、ThreadDeath。这些错误发生时,JVM会选择终止线程。
2.异常——Exception
1.运行时异常
在程序运行过程中产生的错误,是RuntimeException类及其子类异常,如NullPointerException、IndexOutOfBoundsException。
2.非运行时异常
除RuntimeException类及其子类以外的异常。这类异常必须处理,否则无法通过编译。如IOException、SQLException及用户自定义异常。
7.3捕捉并处理异常
1.try...catch代码块
try...catch主要用来对异常进行捕捉并处理,在使用时,还有一个可选的finally代码块
try{ //程序代码块 } catch(Exceptiontype e){ //对Exceptiontype的处理 } finally{ //代码块 } //Exceptiontype是try代码块传递给catch代码块的类型,e是对象名。
Exception对象提供了获取异常的3种方法。
//getMessage()方法:获取相关异常事件信息 //toString()方法:获取异常的性质与类型 //printStackTrance()方法:获取异常事件发生执行堆栈的内容
public class Take { //创建类 public static void main(String[] args) { try { //try代码块中包含可能出现异常的代码 String str = "lili"; System.out.println(str + "年龄是:"); int age = Integer.parseInt("20L"); System.out.println(age); }catch (Exception e){ //catch代码块来获取异常信息 e.printStackTrace(); //输出异常性质 } System.out.println("program over"); //输出信息 } }
2.finally代码块
完整的异常处理语句应包含finally代码块,通常情况下,无论程序是否有异常发生,finally代码都能正常运行。
这三种情况下,finally代码快不会被执行:
-
finally代码块发生异常;
-
前边代码使用System.exit()方法退出程序;
-
程序所在线程死亡;
7.4在方法中抛出异常
1.使用关键字throws抛出异常
在声明方法时使用
//语法格式如下 返回值类型名 方法名 (参数列表) throws 异常类姓名{ 方法体 }
public class Shoot { static void pop() throws NegativeArraySizeException { //定义方法并抛出 NegativeArraySizeException异常 int []arr = new int[-6]; } public static void main(String[] args) { try{ //try语句处理异常信息 pop(); }catch (NegativeArraySizeException e){ System.out.println("pop()方法抛出的异常");//输出的异常信息 } } }
2.使用关键字throw抛出异常
在方法体中使用
//语法格式如下 throw new 异常类型名(异常信息);
public class ThrowTest { public static void main(String[] args) { int num1 = 25; int num2 = 0; int result; if (num2 == 0){ //抛出ArithmeticException异常 throw new ArithmeticException("除数不能为0"); } result = num1/num2; System.out.println(result); } }
关键字throw通常用来抛出用户自定义异常。
throws和throw的区别:
-
关键字throws用在方法声明的后面,表示抛出异常,有方法调用者处理,而关键字throw用在方法体内,用来制造一个异常,由体内的语句处理;
-
关键字throws用于声明这个方法会抛出这种类型的异常,以使他的调用者知道要捕捉这个异常,而关键字throw用于直接抛出一个异常的案例;
-
关键字throws表示出现异常的一种可能性,并不一定会发生某种异常,但如果使用关键字throw,就一定会发生某种异常。
7.5自定义异常
步骤:
创建自定义异常类;
在方法中通过关键字throw抛出异常对象;
如果想要在当前抛出异常类的方法中处理异常,则可以使用try...catch代码块捕捉并处理异常,或在方法的生命处理中船舰一个自定义异常类MyException,该类继承于Exception类。
public class MyException extends Exception{ //创建一个自定义类MyException public MyException(String ErrorMessage){ //构造方法 super(ErrorMessage); //父类构造方法 } } public class Tran { static void avg(int age) throws MyException{ if(age<0){ throw new MyException("年龄不能为负数"); } else{ System.out.println("王师傅今年"+age+"岁了!"); } } public static void main(String[] args) { try{ avg(-50); }catch (MyException e){ e.printStackTrace(); } } }
自定义一场主要用于一下场合
-
使异常信息更加具体;
-
程序某些错误符合Java语法,但不符合实际情况;
-
在分层软件架构中,通常由表现层进行异常捕捉和处理;
7.6异常的处理原则
-
不要过度使用异常处理;
-
不要使用庞大的try...catch代码块;
-
避免使用catch(Exception e);
-
不要忽略捕捉到的异常;
-
如果父类抛出多个异常,则覆盖方法必须抛出相同的异常或者其异常的子类,不可以抛出新的异常。
八、常用类
8.1 String类
java.lang.String
1.创建字符串对象
声明字符串 String 字符串标识符; 声明并初始化字符串常用方式 String 字符串标识符 = 字符串; 通过构造方法创建并初始化字符串对象 String varname = new String ("theString");
空字符串并不是说他的值等于null。” “空字符串也是有符号定义的,实例化的对象。
2.连接字符串
连接字符串可通过 + 实现。
3.字符串操作
1.比较字符串
-
equals()方法。
equals()定义如下 public boolean equals(String str);
String str = "A"; boolean b = str.equals("a"); //相同返回true,不同返回flase
equals()比较的是字符串对象的内容,而 ==比较的是两个对象的内存地址。
-
equalsIgnoreCase()方法。
比较时不区分大小写
定义: public boolean equalsIgnoreCase(String str)
String str = "A"; boolean b = str.equalsIgnoreCase("a");
-
startsWith()方法和endsWith()方法。
分别判断字符串是否以指定的字符串开始或结束
定义如下: public boolean startsWith(String str) public boolean endsWith(String str)
String str = "ABCDE"; boolean bs = str.startsWith("a"); boolean be = str.endsWith("DE");
startsWith()的重载方法,判断字符串从指定索引开始是否为指定的字符串。
定义如下 public boolean startsWith(String prefix,int toffset) String str = "ABCDE"; boolean b = str.startWith("CD",2);
-
compareTo()方法。
用于判断一个字符串是大于、等于还是小于另一个字符串。判断依据是他们在字典中的顺序。
定义如下 public int compareTp(String str)
2.获取字符串的长度
length()方法
String nameStr = "HuangRuiDong"; int i = nameStr.length();
3.字符串大小写转换
toLowerCase(); 将字符串所有大写字母改成小写 toUpperCase(); 将字符串所有小写字母改大写
4.查找字符串
indexOf()方法用于搜索字符或字符串首次出现的位置
lastIndexOf()方法用于搜索字符或字符串最后出现的位置
5.截取字符串
substring()方法,可以从现有字符串中截取子字符串。
public String substring(int beginIndex) public String substring(int beginIndex,int endIndex)
6.去掉字符串的首尾空格
public String trim()
7.替换字符串中的字符或子字符串
定义 public String replace(char oldChar,char newChar)//替换原字符串的字符 public String repalceAll(String regex,String replacement)//替换原字符串的子字符串 public String replaceFirst(String regex,String replacement)//替换原字符串的第一个字符or字符串
8.分割字符串
String类提供了两个重载的split()方法,用于将字符串按照指定的规则分割,并以String型数组的返回方式。
public String[] split(String regex,int limit) //regex为分割规则,limit为分割规则的使用次数
4.格式化字符串
通过format()方法,可以得到经过格式化的字符串对象。format()方法常用于对时期和时间进行格式化。
public static String format(String format,Object obj) public static String format(Locale locale,String format,Object obj)
5.对象的字符串表示
所有类都默认继承Object类,Object类位于java.lang包中。在Object类中有一个public String toString()方法,这个方法用于获取对象的字符串表示。
public class app{ public static void main(String[] args){ Object obj = new Object(); System.out.println(obj.to String()); } }
8.2 StringBuffer类
StringBuffer和String都表示字符串,只不过String不可修改,而StringBuffer可以修改。
1.StringBuffer对象的创建
1.StringBuffer对象的初始化
StringBuffer s = new StringBuffer(); StringBuffer s = new StringBuffer("130");
StringBuffer和String不能直接进行强制类型转换。
2.StringBuffer 类的构造方法
StringBuffer() StringBuffer(int size)//指定容量 StringBuffer(String s)//在s的基础上+16个字符
StringBuffer类似于vector,可通过length()方法获得其实际长度,通过capacity()方法获得其容量。
2. StringBuffer的常用方法
-
append()方法。将其他Java类型数据转化为字符串,再追加到StringBuffer对象的字符内容的末尾。
-
charAt()方法。charAt(int n)方法获取参数n位置上的单个字符,charAt(int n,char ch)用于把参数n位置上的字符换为ch.
-
insert(int index,String str)方法。将str插入到当前StringBuffer对象index位置处。
-
reverse()方法。字符串反转。
-
delete(int startIndex,int endIndex)方法。删除字符串,从startIndex到endIndex-1的位置结束。
-
replace(int startIndex,int endIndex,String str)方法。从startIndex到endIndex-1的位置替换str.
8.3日期的格式化
1. Date类
Date类位于java.util包中
Date date = new Date();//无参构造 Date date = new Date(10000);//计算机本身的时间为1970年1月1日0时,即格林尼治时间。参数表示与格林尼治的时间差,正数为之后的时间,单位ms
2.格式化日期和时间
,
8.4 Math类和Random类
1. Math类
位于java.lang包中
//常见方法 两个常量 E PI abs(); max(); min(); pow(); sqrt(); log(); sin(); asin(); random();
2.Random()类
Random类位于java.util包中
获得随机数
构造方法 public Random();//无参构造 public Random(long seed);//有参构造 Random rd = new Random(); rd.next(); rd.next(m);//返还一个0~m的随机数
8.5 包装类
1. Integer类
java.long包中的Interger、Long、Short分别将int、long、short封装成一个类。
1.构造方法
Integer(int number) Integer(String str) str必须为数值型,后则会抛出异常NumberFormatException
2.常用方法
byteValue();//返还byte型的Integer对象的值 Int compareTo(Integer anotherInteger);//数值上比较两个对象的值,相等0,大于,正值,小于,负值; boolean equals(Object IntegerObj);//比较此对象与指定对象是否相等 int intValue(); short shortValue(); String toString(); Integer valueOf(String str);//返回保存指定String对象的值的Intager对象 int parseInt(String str);//返回包含在由str指定的字符串中的数字的等价整型值
3.常量
-
MAX_VALUE
-
MIN_VALUE
-
SIZE
-
TYPE
2. Boolean类
1.构造方法
Boolean(boolean value) Boolean(String str)//str不为null且忽略大小写时为true
2.常用方法
boolean booleanValue(); boolean equals(Object Obj);//比较此对象与指定对象是否相等,表示同一个对象是才会true boolean parseBoolean(String s);//将字符串参数解析为boolean值 String toString(); Boolean valueOf(String str);//返回保存指定String对象的值的Boolean对象
3.常量
-
TRUE
-
FALSE
-
TYPE
3. Byte类
1.构造方法
Byte(int number) Byte(String str) str必须为数值型,后则会抛出异常NumberFormatException
2.常用方法
byteValue();//返还byte型的Integer对象的值 int compareTo(Integer anotherByte);//数值上比较两个对象的值,相等0,大于,正值,小于,负值; boolean equals(Object \Obj);//比较此对象与指定对象是否相等 Int intValue(); double doubleValue();//以double值返回Byte的值 String toString(); Byte valueOf(String str);//返回保存指定String对象的值的Byte对象 int parseByte(String str);//返回包含在由str指定的字符串中的数字的等价整型值
3.常量
-
MAX_VALUE
-
MIN_VALUE
-
SIZE
-
TYPE
4. Character类
1.构造方法
Character(char value)
2.常用方法
char charValue();//返回此对象的值 int compareTo(Character anotherCharacter);//数值上比较两个对象的值,相等0 boolean equals(Object Obj);//比较此对象与指定对象是否相等 char toUpperCase(char ch);//字符转大写 char toLowerCase(char ch);//字符转小写 char charValue(); short shortValue(); String toString(); boolean isUpperCase(char ch)//判断指定字符是否为大写字符 boolean isLowerCase(char ch);//判断指定字符是否为小写字符
3.常量
-
CONNECTOR_PUNCTUATION
-
UNASSIGNED
-
TITLECASE_LETTER
5. Double类
1.构造方法
Double(double number) Double(String str) str必须为数值型,后则会抛出异常NumberFormatException
2.常用方法
byteValue();//返还byte型的Integer对象的值 int compareTo(Double d);//数值上比较两个对象的值,相等0,大于,正值,小于,负值; boolean equals(Object Obj);//比较此对象与指定对象是否相等 int intValue(); boolean isNaN();//判断是否为非数字,是true,否false String toString(); Double valueOf(String str);//返回保存指定String对象的值的Double对象 double doubleValue();//以double返回此对象的值 long longValue();//以long返回此对象的值,强制转换为long
3.常量
-
MAX_EXPONENT
-
MIN_EXPONENT
-
NEGATIVE_INFINITY
-
POSITIVE_INFINITY
6. Number类
Number类是抽象类,是BigDecimal、BigInteger、Byte、Double、Float、Integer、Long、和Short的父类。
//常用方法 byte byteValue(); int intValue(); float floatValue(); short shortValue(); long longValue(); double doubleValue();