Java OOP day04

笔记:
1.方法的重写(Override):重新写、覆盖
1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
2)重写方法被调用时，看对象的类型
2.重写与重载的区别:——–常见面试题
1)重写(Override):
1.1)发生在父子类中，方法名称相同，参数列表相同，方法体不同
1.2)重写遵循”运行期”绑定，看对象的类型来调用方法
2)重载(Overload):
2.1)发生在一个类中，方法名称相同，参数列表不同，方法体不同
2.2)重载遵循”编译期”绑定，看引用的类型来绑定方法
3.重写遵循”两同两小一大”原则:
* 1.两同:
* 1.1)方法名称相同
* 1.2)参数列表相同
* 2.两小:
* 2.1)子类方法的返回值类型小于或等于父类的
* 2.1.1)void时，必须相同
* 2.1.2)基本数据类型时，必须相同
* 2.1.3)引用类型时，小于或等于
* 2.2)子类方法抛出的异常小于或等于父类的—–异常之后
* 3.一大:
* 3.1)子类方法的访问权限大于等于父类的—–访问控制修饰符之后

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

4.访问控制修饰符:
1)public:公共的，任何类
2)private:私有的，本类
3)protected:受保护的，本类、子类、同包类
4)默认的:什么也不写，本类、同包类
类的访问修饰:public和默认的
类中成员的访问修饰:如上4种都可以
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)何时用:方法的操作仅与参数相关而与对象无关
3)静态块:
3.1)属于类的，在类被加载期间自动执行。
因类只被加载一次，所以静态块也只执行一次，不管放首尾都会先执行。
3.2)何时用:初始化静态资源(图片、音频、视频等)
6.final:最终的—-单独应用的几率不大
1)修饰变量:变量不能被改变
成员变量：要么定义的同时初始化 要么先声明，然后在构造方法中初始化。
局部变量只要用之前初始化之前初始化即可。
2)修饰方法:方法不能被重写
3)修饰类:类不能被继承，但自己可以继承父类。
7.static final/final static:——–应用率高
1)修饰词顺序不限，其修饰的成员变量称为常量，用类名点的方法访问，不建议用对象点访问。
2)必须在声明的同时初始化，不可改变
3)会在编译期被替换为其常量值

重点：重写与重载，static

HW：

1.
public class OverrideAndOverload {

public static void main(String[] args) {
    Overload o=new Overload();
    Super S=new Sub();
    Sub   s=new Sub();
    o.Overload(S);//1.调用Overload方法，重载，根据参数列表自动调用方法，这里S为Super型参数，故得“Super's parameters”，
    //2.Overload方法里，有s.show()方法，这个方法在父子类都有且重写了，故输出的是"i'm Sub"
    int a=1;
    String str="overload";
    System.out.println(a);
    System.out.println(str);//这两个也叫重载，不需要创建对象。
    }    }
    class Overload{
    void Overload(Super s){
    System.out.println("Super's parameters");
    s.show();
}
void Overload(Sub s){
    System.out.println("Sub's parameters");
    s.show();
}   }
class Super{
void show(){                                                                                                                                                     
    System.out.println("i am Super");
}   }
class Sub extends Super{
void show(){
    System.out.println("i'm Sub");
    }

2.
public class StaticDemo {

public static void main(String[] args) {
    Loo l1 = new Loo();
    l1.show();
    Loo l2 = new Loo();
    l2.show();
    System.out.println(Loo.b);// 静态成员变量常常通过类名.来访问
    System.out.println(l1.b);// 不建议。
    Loo.chow();// 方法的操作与参数有关而与对象无关时，用静态方法，它在于提供一些工具方法和工厂方法。}    }
    class Loo {
int a;// 实例变量必须通过对象.来访问
static int b;// 存于方法区，同方法一样只有一份，所有对象共用。

Loo() {
    a++;
    b++;
    System.out.println("构造方法");
}

void show() {
    System.out.println("a=" + a);
    System.out.println("b=" + b);
}

static void chow() {
    // System.out.println("a="+this.a);//静态方法中系统不提供this，意味没对象，只能访问静态成员变量了,就是手动添加也没用。
    System.out.println("b=" + b);
}

static {
    System.out.println("静态块是属于类的，在类被加载期间自动执行，意义在于初始化静态资源");// 先执行，而且只执行一次，因类只被加载一次。
}

3.
package oo.day04;

public class FinalDemo {
public static void main(String[] args){
Foo f=new Foo();
int Num;
System.out.println(Foo.Num);
System.out.println(f.Num);//不建议
}

}

class Foo{
final int a=1;//1.要么定义的同时初始化2.要么先声明，然后在构造方法中初始化。
final int b;
Foo(){
b=1;
final int c;//局部变量只要用之前初始化之前初始化即可
}
final void show(){}
public static final int Num=100;
public final static int MuN=100;

}
final class foo extends Foo{
//void show();//final修饰的方法不能重写
}
//class goo extends foo{}//final 修饰的方法不能被继承，但可以继承别人。

//static final：顺序不限，应用率高，其修饰的成员变量称为常量，必须在声明的同时初始化，不可改变.会在编译期被替换为其常量值