OOP Unit04 继承的意义（下） 、 访问控制 、 static和final

1.方法的重写(Override):重新写、覆盖
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型

重写：继承了一个餐厅(中餐)
A:继承后依然还是做中餐———不需要重写
B:继承后改为做西餐————-重写
C:继承后在中餐基础上加西餐—–重写+super

package oo.day04;
//重写的演示
public class OverrideDemo {
    public static void main(String[] args) {}
}
/** 重写需遵循"两同两小一大"原则:* -----------一般都是一模一样* 1)两同:* 1.1)方法名称相同* 1.2)参数列表相同* 2)两小:* 2.1)子类方法的返回值类型小于或等于父类的* 2.1.1)void时，必须相等* 2.1.2)基本类型时，必须相等* 2.1.3)引用类型时，小于或等于* 2.2)子类方法抛出的异常小于或等于父类的-----异常之后* 3)一大:* 3.1)子类方法的访问权限大于或等于父类的-----访问控制修饰符之后*///父类大，子类小
class Aoo{
    void say(){}double sayHi(){
   return 0.0;}public Aoo test(){
   return null;}Boo show(){
   return null;}
}
class Boo extends Aoo{
    //int say(){return 1;} //编译错误，void时必须相等//int sayHi(){return 0.0;} //编译错误，基本类型时必须相等public Boo test(){
   return null;} //正确，引用类型小于//Aoo show(){return null;} //编译错误，引用类型必须小于或等于
}

2.方法重写与重载的区别:——常见面试题
1)重写(Override):
1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
1.2)遵循”运行期”绑定，根据对象的类型来调用方法
2)重载(Overload):
2.1)发生在同一类中，方法名称相同，参数列表不同，方法体不同
2.2)遵循”编译期”绑定，根据引用(参数)的类型来绑定方法

重载看引用，重写看对象
编译期:.java，经编译，生成.class—–检查语法
运行期:JVM加载.class并运行.class—–加载对象

package oo.day04;
//重写与重载的区别
public class OverloadOverrideDemo {
    public static void main(String[] args) {//重载看引用，重写看对象Eoo eoo = new Eoo();Coo o = new Doo(); //向上造型eoo.test(o); //重载看引用(参数)}
}class Eoo{
    void test(Coo o){System.out.println("父型参数");o.show(); //重写看对象}void test(Doo o){System.out.println("子型参数");o.show();}
}class Coo{
    void show(){System.out.println("父类Show");}
}
class Doo extends Coo{
    void show(){System.out.println("子类Show");}
}

3.package:
1)作用:避免类名的冲突
2)包名可以有层次结构
3)类的全称: 包名.类名
4)建议:包名所有字母都小写
import:
1)同包中的类可以直接访问
2)不同包中的类不能直接访问，方式如下两种:
2.1)先import声明类而后再直接使用—建议
2.2)类的全称——太繁琐，不建议

建议命名规则:
域名反写 . 项目名称 . 模块名称 . 类名
cn.tedu . a . student .
com.taobao . b . teacher .
com.jd

4.访问控制修饰符:
1)public:公开的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、子类、同包类
4)默认的:什么也不写，本类、同包类
类的访问修饰符有:public和默认的
类中成员的访问修饰符有:如上4种都可以

演示public，protected，private:
F00：

package oo.day04;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{ //演示privatevoid show(){Foo o = new Foo();o.a = 1;o.b = 2;o.c = 3;//o.d = 4;}
}

Hoo:

package oo.day04.vis;
import oo.day04.Foo;public class Hoo {
     //演示包void show(){Foo o = new Foo();o.a = 1;//o.b = 2;//o.c = 3;//o.d = 4;}
}class Ioo extends Foo{
     //演示protected,跨包继承void show(){a = 1;b = 2;//c = 3;//d = 4;}
}

数据私有化(private)，行为公开化(public):

class Card{private String cardId;private String cardPwd;private double balance;public boolean payMoney(double money){if(balance>=money){balance-=money;return true;}else{return false;}}public boolean checkPwd(String pwd){if(pwd.equals(cardPwd)){return true;}else{return false;}}
}

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

2)静态方法:
2.1)由static修饰
2.2)属于类的，存储在方法区中，只有一份
2.3)常常通过类名点来访问
2.4)静态方法没有隐式的this传递，
静态方法中不能直接访问实例成员
2.5)何时用:方法的操作仅与参数相关而与对象无关
静态类：
无论a1,a2,a3,…,a100，
去sort(arr)，最终的结果都一样
说明sort()方法，与对象无关，而仅与参数相关

3)静态块:
3.1)由static修饰
3.2)属于类的，在类被加载期间自动执行，
类只被加载一次，所以静态块也只执行一次
3.3)何时用:常常用于初始化静态资源(图片、音频、视频等)

package oo.day04;
//static的演示
public class StaticDemo {public static void main(String[] args) {Joo o1 = new Joo();o1.show();Joo o2 = new Joo();o2.show();System.out.println(Joo.b); //2System.out.println(o1.b); //2，不建议System.out.println(o2.b); //2Koo.test();Loo o3 = new Loo();Loo o4 = new Loo();}
}class Loo{ //演示静态块static{System.out.println("静态块");}Loo(){System.out.println("构造方法");}
}class Koo{ //演示静态方法int a;static int b;void show(){System.out.println(a);System.out.println(b);}static void test(){ //没有隐式this传递//System.out.println(a); //没有this意味着没有对象，而a必须要通过对象来访问，所以编译错误System.out.println(b);}
}class Joo{ //演示静态变量int a; //实例变量:堆中，有几个对象有几份static int b; //静态变量:方法区中，一份Joo(){a++;b++;}void show(){System.out.println("a="+a);System.out.println("b="+b);}
}

6.final:最终的
1)修饰变量:变量不可被改变
2)修饰方法:方法不可被重写
3)修饰类: 类不可被继承

package oo.day04;
//final的演示
public class FinalDemo {
    public static void main(String[] args) {}
}final class Poo{
    } //演示final修饰类
//class Qoo extends Poo{} //编译错误，final的类不能被继承class Roo{
    }
final class Soo extends Roo{
    }class Noo{
     //演示final修饰方法void show(){}final void test(){}
}
class Ooo extends Noo{
    void show(){}//void test(){} //编译错误，final的方法不能被重写
}/** final可以修饰成员变量，只有两种初始化方式:* 1)声明同时初始化* 2)构造方法中初始化* final可以修饰局部变量，只要在使用之前初始化即可*/
class Moo{
     //演示final修饰变量final int a = 5;final int b;Moo(){b = 6;}void show(){final int c; //用之前初始化即可//a = 55; //编译错误，final的变量不能被改变}
}