【java基础面向对象】方法的重写 package和import包 访问控制修饰符 static fin

目录

1. 方法的重写(override/overriding)：重新写、覆盖

2. package和import：

3. 访问控制修饰符：-----------------------保护数据的安全

4. static：静态的

5. final：最终的、不可改变的---------------------应用率低

6. static final常量：应用率高

7. 抽象方法：

8. 抽象类：

1. 方法的重写(override/overriding)：重新写、覆盖

发生在父子类中，方法名相同，参数列表相同 重写方法被调用时，看对象的类型--------------------------这是规定，记住就可以

class 餐馆{ void 做餐(){ 做中餐 } } //1)我还是想做中餐---------------不需要重写 class Aoo extends 餐馆{ } //2)我想改做西餐-----------------需要重写 class Aoo extends 餐馆{ void 做餐(){ 做西餐 } } //3)我想在中餐基础之上加入西餐------需要重写(先super中餐，再加入西餐) class Aoo extends 餐馆{ void 做餐(){super.做餐(); 做西餐 } }

遵循"两同两小一大"原则：---------------了解即可，一般都是一模一样的两同：方法名相同 参数列表相同两小：派生类方法的返回值类型小于或等于超类方法的 void和基本类型时，必须相等 引用类型时，小于或等于

//超类大，派生类小 class Aoo{ //超类(大) void show(){} double test(){ return 0.0; } Boo sayHi(){ return null; } Aoo say(){ return null; } } class Boo extends Aoo{ //派生类(小) //int show(){ return 1; } //编译错误，void时必须相等 //int test(){ return 0; } //编译错误，基本类型时必须相等 //Boo sayHi(){ return null; } //编译错误，引用类型时必须小于 或等于 Boo say(){ return null; } //正确，小于或等于 }

派生类方法抛出的异常小于或等于超类方法的-------------------API异常之后一大：派生类方法的访问权限大于或等于超类方法的

2. package和import：

package：声明包作用：避免类的命名冲突 同包中的类不能同名，但不同包中的类可以同名 类的全称：包名.类名 建议：包名所有字母都小写，包名常常有层次结构import：导入类同包中的类可以直接访问，但不能包中的类不能直接访问，若想访问： 先import导入类再访问类-----------建议 类的全称---------------------------------太繁琐、不建议

3. 访问控制修饰符：-----------------------保护数据的安全

public：公开的，任何类 private：私有的，本类 protected：受保护的，本类、派生类、同包类------------------------应用率低 默认的：什么也不写，本类、同包类--------------------------------------java不建议默认权限

说明： 1. 类的访问权限，只能是public或默认的。而类中成员的访问权限，如上4种都可 以。 2. 访问权限由低到高依次为：private<默认的<protected<public

//访问控制修饰符的演示 public class Coo { public int a; //任何类 protected int b; //本类、派生类、同包类 int c; //本类、同包类 private int d; //本类 void show(){a = 1; b = 2; c = 3; d = 4; } } class Doo{ //----------------------演示private void show(){ Coo o = new Coo(); o.a = 1; o.b = 2; o.c = 3; //o.d = 4; //编译错误 } }

import ooday04.Coo; public class Eoo { //-----------------演示同包的 void show(){ Coo o = new Coo(); o.a = 1; //o.b = 2; //编译错误 //o.c = 3; //编译错误 //o.d = 4; //编译错误 } } class Foo extends Coo{ //跨包继承-------演示protected void show(){ a = 1; b = 2; //c = 3; //编译错误 //d = 4; //编译错误 } }

4. static：静态的

静态变量： 由static修饰属于类，存储在方法区中，只有一份 常常通过类名点来访问 何时用：所有对象所共享的数据(图片、音频、视频等)

//演示静态变量 class Goo{ int a; static int b; Goo(){ a++; b++; } void show(){System.out.println("a="+a+",b="+b); } } public class StaticDemo { public static void main(String[] args) { Goo o1 = new Goo(); o1.show(); Goo o2 = new Goo(); o2.show(); Goo o3 = new Goo(); o3.show(); System.out.println(Goo.b); //常常通过类名点来访问 } }

静态方法：由static修饰 属于类，存储在方法区中，只有一份 常常通过类名点来访问 静态方法中没有隐式this传递，不能直接访问实例成员 何时用：方法的操作与对象无关(不需要访问对象的属性)

//演示静态方法 class Hoo{ int a; //实例变量(由对象来访问) static int b; //静态变量(由类名来访问) void show(){ //有this System.out.println(this.a); System.out.println(Hoo.b); } static void test(){ //没有this //静态方法中没有隐式this传递 //没有this就意味着没有对象 //而实例变量a是必须由对象来访问的 //所以如下代码发生编译错误 //System.out.println(a); //编译错误 System.out.println(Hoo.b); } } //演示何时设计为静态方法 class Ioo{ int a; //对象的属性 //在show()中访问了对象的属性，意味着show()方法与对象有关，不能设计为静态方 法 void show(){ System.out.println(a); } //在plus()中没有访问对象的属性，意味着plus()方法与对象无关，可以设计为静态 方法 static int plus(int num1,int num2){ int num = num1+num2; return num; } } public class StaticDemo { public static void main(String[] args) { Hoo.test(); //常常通过类名点来访问 } }

静态块：由static修饰 属于类，在类被加载期间自动执行，因一个类只被加载一次，所以静态块只执行一次 何时用：加载/初始化静态资源(图片、音频、视频等)

//演示静态块 class Joo{ static{ System.out.println("静态块"); } Joo(){ System.out.println("构造方法"); } } public class StaticDemo { public static void main(String[] args) { Joo o4 = new Joo(); Joo o5 = new Joo(); Joo o6 = new Joo(); } }

5. final：最终的、不可改变的---------------------应用率低

修饰变量：变量不能被改变

class Aoo{

final int a = 5;

void show(){

//a = 55; //编译错误，final的变量不能被改变

}

}

修饰方法：方法不能被重写

class Boo{

final void show(){ }

void test(){ }

}

class Coo extends Boo{

//void show(){ } //编译错误，final的方法不能被重写

void test(){ }

}

修饰类：类不能被继承

final class Doo{}

//class Eoo extends Doo{} //编译错误，final的类不能被继承

class Foo{}

final class Goo extends Foo{} //正确，不能当老爸，但能当儿子

6. static final常量：应用率高

必须声明同时初始化 常常通过类名点来访问，不能被改变 建议：常量所有字母都大写，多个单词之间用_分隔 编译器在编译时会将常量直接替换为具体的数，效率高 何时用：数据永远不变，并且经常使用

public class StaticFinalDemo { public static void main(String[] args) {

System.out.println(Hoo.PI); //常常通过类名点来访问

//Hoo.PI = 3.1415926; //编译错误，常量不能被改变

//1)加载Ioo.class到方法区中

//2)静态变量num一并存储在方法区中

//3)到方法区中获取num的值并输出

System.out.println(Ioo.num);

//编译器在编译时会将常量直接替换为具体的值，效率高

//相当于System.out.println(5);

System.out.println(Ioo.COUNT);

}

} class Ioo{

public static int num = 5; //静态变量

public static final int COUNT = 5; //常量

}

class Hoo{

public static final double PI = 3.14159;

//public static final int NUM; //编译错误，常量必须声明同时初始化

}

7. 抽象方法：

由abstract修饰 只有方法的定义，没有具体的实现(连{}都没有)

8. 抽象类：

由abstract修饰 包含抽象方法的类必须是抽象类 抽象类不能被实例化(new对象) 意味着画对象的行为为共有行为，所以设计在SeaObject超类中， 每个对象画的代码都是一样的，所以设计为普通方法 派生类： 重写抽象类中的所有抽象方法-----------变不完整为完整 也声明为抽象类------------------------------一般不这么做 抽象类的意义： 封装共有的属性和行为---------------------代码复用 为所有派生类提供统一的类型------------向上造型(代码复用) 可以包含抽象方法，为所有派生类提供统一的入口(向上造型后能点出来)，同时可以达到 强制必须重写的目的

抽象方法存在的意义是什么？

保证当发生向上造型时，通过超类的引用能点出来那个方法-----------保证能点出方法来

既然抽象方法的意义是保证能点出来，那为什么不设计为普通方法呢?

设计为普通方法，意味着派生类可以重写也可以不重写，但设计为抽象方法，则可以强

制派生类必须重写-----------强制派生类重写，可以达到统一的目的

【java基础面向对象】方法的重写 package和import包 访问控制修饰符 static final static final 抽象方法