一.方法的重写(Override):重新写 覆盖
1>发生在父子类中,方法名称相同,参数列表相同,方法体不同
2>重写方法被调用时,看对象的类型
->两同两小一大: 方法名称相同,参数列表相同
子类方法的返回值类型小于或等于父类方法的
void和基本类型时,必须相等
引用类型时,小于或等于
子类抛出的异常小于或等于父类的
子类方法的访问权限大于或等于父类的
public class Eoo {
public static void main(String[] args) {
Aoo ab=new Boo();//Aoo的引用指向Boo的对象 向上造型
ab.show();//向上造型时,调用父类和子类共有的方法时,则调用子类重写的方法
// ab.bshow();//但子类特有的方法不能调用
Boo b=new Boo();
b.aShow();//子类可以调用父类的方法
b.show();
Aoo a=new Aoo();
a.show();
// a.bShow();//父类不能调用子类的方法
}
}
class Aoo {
public void show(){
System.out.println("父类Aoo的show方法");
}
public void aShow(){
System.out.println("父类Aoo的aShow方法");
}
}
class Boo extends Aoo{
public void show(){
System.out.println("子类Boo的show方法");
}
public void bShow(){
System.out.println("子类Boo特有的bShow方法");
}
}
二.重写与重载的区别 ————–常见面试题
1>重写(override):
1.1>发生在父子类中,方法名称相同,参数列表相同,方法体不同
1.2>遵循”运行期”绑定,根据对象的类型来调用方法 (看对象)
2>重载(overload):
2.1>发生在一个类中,方法名称相同,参数列表不同,方法体不同
2.2>遵循”编译器”绑定,根据引用的类型来绑定方法 (看引用)
三.package和import
package: org.apache.commons.lang.StringUtils 域名反写.项目名称.模块名称.类名
1>作用:避免类的命名冲突
2>包名可以有层次结构,类的全称:包名,类名
3>同包中的类不能同名,但是不同1包中的类时可以同名的
4>建议:包名所有字母都小写
import:
1>同包中的类可以直接访问
不同包中的类是不能直接访问的,想访问有两种方式:
1.1)先import再使用类———建议
1.2)类的全称—————–太繁琐,不建议
四.访问控制修饰符
访问修饰符 访问权限
1>public 公共的 任何类
2>protected 受保护的 本类、子类、同包类
3> 什么也不写 默认的 本类、同包类
4>private 私有的 本类
类的访问修饰可以是public和默认的
类中成员的访问修饰如上4种都可以
(非同包例子可新建包自行尝试)
public class Foo {
public int a; //任何类
protected int b;//本类 子类 同包类
int c; //本类 同包类
private int d; //本类
void show(){
a=1;
b=2;
c=3;
d=4;
}
}
class Goo{
void show(){
Foo o=new Foo();
o.a=1;
o.b=2;
o.c=3;
// o.d=4;
}
}
五.static:静态的
成员变量,分两种:
1>实例变量:没有static修饰,存储在堆中,有几个对象就有几份
对象 点 来访问
2>静态变量:由static修饰,属于类的,存储在方法区,只有一份
类名 点 来访问
1>静态变量:
1.1>由static修饰的
1.2>属于类,存储在方法区中,只有一份
1.3>常常通过类名 点 来访问(对象 点 也可访问-不建议使用)
1.4>何时用:所有对象所共享的数据(图片 音频 视频等)
2>静态方法:
2.1>由static修饰
2.2>属于类的,存储在方法区,只有一份
2.3>常常通过类名 点来访问
2.4>静态方法没有隐式的this传递 (没有this 意味着没有对象 实例成员必须通过对象 点来访问 所以静态方法中不能访问实例成员)
静态方法中不能直接访问实例成员
2.5>何时用:方法的操作仅与参数相关而与对象无关
3>静态块:
3.1>由static修饰
3.2>属于类的,在类被加载期间自动执行的,
因为类只被加载一次,所以静态块也只执行一次
3.3>何时用:加载/初始化静态资源(图片 音频 视频等)
public class StaticDemo {
public static void main(String[] arg){
Qoo q=new Qoo();
Roo r=new Roo();
r.ma();
Joo j1=new Joo();
j1.show();
Joo j2=new Joo();
j2.show();
}
}
class Joo{
int a;
static int b;
Joo(){
a++;
b++;
}
void show(){
System.out.println("a="+a);
System.out.println("b="+b);
}
}
class Roo{
public static void ma(){
System.out.println(Qoo.Num);
}
}
class Qoo{
public static final int Num=100;
static{
System.out.println("static");
}
Qoo(){
System.out.println("gouzao");
}
}
六.final:最终的,不可改变的
两种初始化:
声明同时初始化
构造函数中初始化
1>修饰变量:变量不能被改变
2>修饰方法:方法不能被重写
3>修饰类:类不能被继承
public class FinalDemo {
public static void main(String[] args) {
}
}
class Ooo {
final void show(){
}
}
final class Poo extends Ooo{
// void show(){
//
// }
}
class Moo{
final int a=5;
final int b;
Moo(){
b=6;
}
void show(){
final int c;
// a=6;
}
}