关闭

黑马程序员面试题面向对象二(多态,抽象类abstract,接口Interface,内部类,异常Exception,包package,String类,StringBuffer)

标签: java基础面试题黑马程序员
670人阅读 评论(1) 收藏 举报
分类:
 --------- android培训java培训、期待与您交流!---------

一.多态

1.多态的概念
(1) 多态:可以理解为事物存在的多种体现形态。
(2)多态的体现:
父类的引用指向了自己的子类对象。

方法的重载。

方法的覆盖。

(3)多态的前提:
<1>必须是类与类之间有关系,要么继承,要么实现。
<2>通常还有一个前提:存在覆盖。

(4)多态的好处:
多态的出现大提高了程序的扩展性。

(5)多态的弊端:
只能使用父类的引用访问父类中的成员。

2.转型(引用类型强制转换)
(1)类型提升--->向上转型  //  Animal a = new Cat();
(2)转成子类型--->向下转型 //  Cat c = (Cat)a;
3.多态中成员的特点
(1)多态中成员函数的特点:
<1>在编译时期:参阅引用型变量所属的类中是否有调用的方法,如果有,编译通过。如果没有,编译失败。
<2>在运行时期:参阅对象所属的类中是否有调用的方法。
<3>总结:成员函数在多态调用时,编译看左边,运行看右边。
(2)多态中成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类).
(3)多态中,静态成员函数的特点:
无论编译和运行,都参考左边。

二.抽象类

1.概述
(1)当多个类中出现相同功能,但是功能主体不同,这时可以进进向上抽取。
(2)这时只抽取功能定义,而不抽取功能主体。
(3)抽象就是笼统的,不具体的,看不懂的。

2.抽象类的特点:
(1)抽象方法一定在抽象类中。
(2)抽象方法和抽象类都必须被abstract关键字修饰。
(3)抽象类不可以用new创建对象,因为调用抽象方法没意义。
(4)抽象类中的抽象方法要被使用,必须由子类复写齐所有的抽象方法后,建立子类对象调用。
(5)如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
(6)抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。

三.接口

1.接口:
初期理解,可以认为是一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以
通过接口的形式来表示。
2.区别:
class用于定义类。
interface用于定义接口。
3.接口的格式:interface{}
4.接口定义的格式特点:
(1)接口中常见定义:常量,抽象方法。
(2)接口中的成员都有固定修饰符。
常量:public static final
方法:public abstract
5.注意:
(1)接口中的成员都是public的。
(2)接口是不可以创建对象的,因为有抽象方法。需要被子类实现,子类对接口中的抽象方法
全部覆盖后,子类才可以实例化,否则子类是一个抽象类。
6.接口的特点:

(1)接口可以被多实现,也可以多继承。
(2)接口是对外暴露的规则。
(3)接口是程序的功能扩展。
(4)接口降低了偶合性
(5)类与接口之间是实现关系,而且类可以继承一个类的同时实现多个接口。
(6)接口与接口之间可以有继承关系。
(7)基本功能定义在类中,扩展功能定义在接口中。

四.内部类

1.内部类
(1)将一个类定义在另一个类的里面,对里面那个类就称为内部类,或叫内置类,嵌套类。
(2)访问特点:
<1>内部类可以直接访问外部类中的成员,包括私有成员。
<2>外部类要访问内部类中的成员,必须要建立内部类的对象。

3)注意:
<1>内部类之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用。
格式为:外部类名.this

<2>内部类可以被私有封装。
<3>内部类可以被static修饰。

2.静态内部类
(1)访问格式:
<1>当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中直接建立内部类对象。
格式:外部类名.内部类名 变量名 = 外部类对象.内部类对象
如: Outer.Inner in = new Outer().new Inner();
<2>当内部类在成员位置上,就可以被成员修饰符所修饰。
比如:private:将内部类在外部类中进行封装。
static :内部类就具备static特性

a.当内部类被static修饰后,只能直接访问外部类中的static成员,出现了访问局限。
b.在外部其他类中,如何直接访问static内部类的静态成员呢?
new Outer.Inner().function();
c.在外部其他静态类中,如何直接访问static 内部类的静态成员呢?
Outer.Inner.function();

(2)注意:
<1>当内部类中定义了静态成员,该内部类必须是static的。
<2>当外部类中的静态方法访问内部类时,内部类也必须是静态的。

3.内部类的定义原则:

当描述事物时,事物的内部还有事物,该事物用内部类来描述,因为内部事物在使用外部事物的内容。

4.匿名内部类:

要点: 
(1)内部类只有定义在成员位置上时,才能被private和static所修饰,一般内部类是不会被public所修饰的。
(2)内部类可以被写在任意位置上,成员也可以。局部也可以。
(3)非静态,没对象不运行
(4)从内部类中访问局部变量,需要被声明为最终类型(加final).
(5)内部类定义在局部时:
<1>不可以被成员修饰符修饰。
<2>可以直接访问外部类中的成员,因为还持有外部类中的引用,但是不可以访问它所在的局部中的变量,
只能访问被final修饰的局部变量。

注意:
(1)匿名内部类其实就是内部类的简写格式。
(2)定义匿名内部类的前提:内部类必须是继承一个类或者接口。
(3)匿名内部类的格式:new 父类或接口(){定义子类的内容}
(4)其实匿名内部类就是一个匿名子类对象,而且这个对象有点胖,可以理解为带内容的对象。
(5)匿名内部类中定义的方法不要超过3个,最好是2个或者1个。
(6)定义匿名内部类,就是为了简化书写,覆盖方法。

五.Object类

1.Object类
(1)Object:是所有对象的直接或者间接父类,是一个超类,该类中定义的肯定是所有对象都具备的功能。
(2)Object类中已经提供了对对象是否相同的比较方法,如果自定义类中也有比较相同的功能,没必要
重新定义,只要沿袭父类中的功能,建立自己特有的比较内容即可,这就是覆盖。
(3)java认为所有对象都具备比较性,该方法equals定义在Object中。
2.Object中方法:
(1)toString():返回该对象的字符串表示,所有对象都可以变成字符串打印。
(2)hashCode():返回该对象的哈希码值。
(3)getClass():返回此Object的运行时类。

(4)wait();

(5)notify();

(6)notifyAll();

六.final关键字

final:意为“最终”,是一个修饰符。
(1)可以修饰类,函数,变量。
(2)被final修饰的类,不可以被继承。
(3)被final修饰的方法不可以被复写。如:final void show(){}//最终方法
(4)被final修饰的变量是一个常量。如:final int x=3;
(5)内部类定义在类中的局部位置上时,只能访问该局部被final修饰的局部变量。

七. 异常类

1 异常概述: 异常是对问题的描述,将问题封闭成对象  以便抛出和处理。

2 异常体系:

Throwable

         |----------Error

         |----------Exception

         |----------RuntimeException

3 异常体系的特点:

 异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。

4 throw 和Throws

throw定义在函数内,用于抛出异常对象。
throws定义在函数上,用于抛出异常类,可抛出多个异常 用逗号隔开。

5 当函数内有throw抛出异常对象,并未进行try处理 必须要在函数上声明,否则编译失败,

注意:RuntimeException及它的子类除外,也就是说,函数内如果抛出了RuntimeException异常,函数上可以不用声明,

如果函数声明了异常,调用者需要进行处理 处理方法可以throws也可以try.

6异常分为两种

(1)编译时被检测异常Exception,如果没有处理,那么编译失败,该异常可以被标识,代表可以被处理。

(2)运行时异常RuntimeException 不需要处理,该异常发生,让程序停止,需要对代码进行修正。

7,异常处理语句:

try{被检测的代码}catch{处理的代码}finally{一定会执行的语句} 

 finally通常是关闭资源,释放资源使用,只有当执行到System.exit(0)的时候 finally中的代码不会被执行。遇到return也要执行。

8自定义异常

(1)定义类继承Exception或RunTimeException

<1>为了让该自定义类具备可抛性。
<2>让该类具备操作异常的共性方法。

(2)当要定义自定义异常的信息时,可以使用父类已经定义好的功能,将异常信息传递给父类的构造函数。
class MyException extends Exception
{
       MyException(String message)
       {
         super(message);
       }
}

自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装。

10异常的好处:
(1)将问题进行封装。
(2)将正常流程代码和问题处理代码相分离,方便于阅读。

11.异常处理原则:
(1)处理方式有两种:try或throws.
(2)调用到抛出异常的功能时,抛出几个就处理几个,一个try可对应多个catch.
(3)多个catch时,父类的catch放到最下面,否则子类的catch执行不到。
(4)catch内,需要定义针对性的处理方式,不要简单的定义printStackTrace,输出语句,也不要不写。
(5)当捕捉到的异常,本功能处理不了时,可以继续在catch中抛出。

12.异常的注意事项:
在子父类覆盖时:
(1)子类抛出的异常必须是父类的异常的子类或子集。
(2)如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try处理不能抛出。


八. 包

1.包:
包也是一种封装形式,可对类文件进行分类管理,给类提供多层命名空间。
写在程序文件的第一行,类名的全称是:包名.类名

2.包的好处:
包的出现可以让类文件和java的源文件相分离,可以很方便地只将类文件提供给别人使用。

3 包与包之间的访问:

(1)一个包中的类要被访问,必须要有足够大的权限,所以被访问的类要被public修饰。
(2)类公有后,被访问的成员也要公有才可以被访问。
(3)包与包之间进行访问,被访问的包中的类以及类中的成员,需要public修饰。
(4)不同包中的子类还可直接访问父类中被protected权限修饰的成员。
(5)包与包之间可以使用的权限只有两种:public,protected.

4.java中四种权限
                           public     protected    default       private
同一个类中:     OK             OK             OK         OK

同一个包中:    OK             OK            OK

不同包子类:    OK             OK

不同包中:        OK

5.import
(1)为了简化类名的书写,使用一个关键字import,import导入的是包中的类。
(2)import packb.*;为导入包中所有的类,尽量不要写通配符*,需要用到哪个类就导入哪个类,
都导进来比较占内存。
(3)建立定义包名不要重复,可以使用url来完成定义,因为url是唯一的。
如:package cn.itcast

(4)包和子包中有重名类时,创建对象必须加包名。
如:packb包和子包haha中都有DemoC,创建packb包中DemoC对象代码为:
packb.DemoC c = new packb.DemoC();

6.jar包
(1)java中的jar包是通过工具jar.exe完成的。
(2)java的压缩包方便项目的携带,方便于使用,只要在classpath设置jar路径即可。
(3)数据库驱动,SSH框架等都是以jar包体现的。

 九. String类

1.String概述:

 (1)public final class String   此类不能有子类,也就是操作字符串的功能不可以被复写。
 (2)String类代表字符串,java程序中所有的字符串字面值(如:"abc")都作为此类的实例实现。
 (3)字符串是常量,它们的值在创建后不能更改。
2.s1和s2的区别:
String s1="abc";
String s2=new String("abc");

s1==s2   flase;     ==比较的是两个对象的引用地址  这是两个不同的对象 所以false;

s1.equals(s2)  true   equals本身也是比较两个对象的引用地址

但是在这里被String字符串复写了,比较对象的内容是否相同。
s1在内存中有一个对象。
s2在内存中有两个对象。

3.String 类在内存中的原理分析:
String类在内存中有一个常量池,也就是一个数组,将字符按指定顺序存入数组来组成字符串。

4 String常见方法:

获取:

(1)获取长度:int length()
(2)根据位置获取字符:char charAt(int index)
(3)根据字符获取位置:
int indexOf(int ch):返回ch在字符串中第一次出现的位置。
int indexOf(int ch,int fromIndex):从fromIndex指定位置开始,获取ch在字符串中出现的位置。
int indexOf(String str):返回str在字符串中第一次出现的位置。
int indexOf(String str,int fromIndex):从fromIndex指定位置开始,获取str在字符串中出现的位置。
int lastIndexOf(int ch):返回字符在字符串中最后一次出现的索引位置。

判断:
(1)字符串中是否包含某一个子串:boolean contains(str)
(2)字符串中是否有内容:boolean isEmpty()
(3)字符串是否是以指定内容开头:boolean startsWith(str)
(4)字符串是否是以指定内容结尾:boolean endsWith(str)
(5)判断字符串内容是否相同(复写Object类中的equals方法):boolean equals(str)
(6)判断内容是否相同并忽略大小写:boolean equalsIgnoreCase()

转换:

(1)将字符数组转成字符串:
构造函数:
String(char[])
String(char[],offset,count)//将字符数组中的一部分转成字符串。
静态方法:
static String copyValueOf(char[])
static String copyValueOf(char[] data,int offset,int count)
static String valueOf(char[])
(2)将字符串转成字符数组:char[] toCharArray()
(3)将字节数组转成字符串:
String(byte[])
String(byte[],offset,count)
(4)将字符串转成字节数组:byte[] getBytes()
(5)将基本数据类型转成字符串:
static String valueOf(int)
static String valueOf(double)
注:3+"" <==> String.valueOf(3);
字符串和字节数组在转换过程中,是可以指定编码表的。
替换和切割:
(1)String replace(oldChar,newChar);
(2)String replace(charSequence target,charSequence replacem):替换字符串
(3)切割:String[] split(regex)
(4)获取子串:
String substring(begin)
String substring(begin,end)
比较和去除空格:
(1)将字符串转成大写或小写:
String toUpperCase();
String toLowerCase();
(2)将字符串两端的多个空格去除:String trim();
(3)对两个字符串进行自然顺序的比较:int compareTo(String);

十.StringBuffer        

1.关于StringBuffer
(1)字符串的组成原理就是通过该类实现的。
(2)StringBuffer可以对字符串内容进行增删。
(3)StringBuffer是一个容器。
(4)很多方法与String相同。
(5)StringBuffer是可变长度的。

2.public final class StringBuffer
StringBuffer不能被继承,它是字符串的缓冲区。
缓冲区特点:
长度可变。
可操作多个数据类型。
最终会通过toString方法变成字符串.才可以操作。

3.StringBuffer中方法:
(1)存储:
StringBuffer append():将指定数据作为参数添加到已有数据结尾处。
StringBuffer insert(index,data):可将数据插入到指定index位置。
(2)删除:
StringBuffer delete(start,end):删除缓冲区中的数据,包含start,不包含end.
StringBuffer deleteCharAt(index):删除指定位置的字符。
(3)获取:
char charAt(int index);
int indexOf(String str);
int lastIndexOf(String str);
int length();
String substring(int start,int end);
(4)修改:
StringBuffer replace(start,end,String str);
void setCharAt(int index,char ch);
(5)反转:
StringBuffer reverse();
(6)将缓冲区中指定数据存储到指定字符数组中:
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin);

4StringBuilder和StringBuffer区别                                    

(1)StringBuffer是线程同步,多线程中使用。
StringBuilder是线程不同步,单线程使用。

        (2)StringBuilder:一般开发中用StringBuilder 比StringBuffer更高效。


十一. 基本数据类型包装类

1.基本数据类型对象包装类:
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
2.基本数据类型对象包装类的最常见作用:
---就是用于基本数据类型和字符串类型之间做转换
(1)基本数据类型转成字符串:
基本数据类型 + "";
基本数据类型.toString(基本数据类型值);如:Integer.toString(34)
(2)字符串转成基本数据类型:
xxx a = XXX.parseXXX(String str);//静态方法
如:int a = Integer.parseInt("123");
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");
3.十进制---->其他进制
toBinaryString();//2
toHexString();//16
toOctalString();//8
4.其他进制--->十进制
parseInt(string,radix);如:parseInt("110",10);
5.基本数据类型对象包装类新特性
Integer x=4;//自动装箱,隐式完成了new Integer(4)动作。
x=x+2;//x进行自动拆箱,变成了int类型,和2进行加法运算,再将和进行装箱赋给x;

注:x的拆箱原理:x.intValue();
Integer x=null;//NullPointException空指针异常



0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:7188次
    • 积分:202
    • 等级:
    • 排名:千里之外
    • 原创:12篇
    • 转载:2篇
    • 译文:0篇
    • 评论:1条
    文章分类
    文章存档