Day15面向对象

编程入门行业动态更新时间:2024-10-25 04:22:15

Day15<a href=https://www.elefans.com/category/jswz/34/1769334.html style= 面向对象"/>

Day15面向对象

Day15面向对象-方法的重写,控制修饰符,static,package：

精华笔记：

方法的重写(override/overriding)：重新写、覆盖
- 发生在父子类中，方法名相同，参数列表相同
- 重写方法被调用时，看对象的类型--------------------------规定，记住就可以
- 遵循"两同两小一大"原则：
  - 两同：
    - 方法名相同
    - 参数列表相同
  - 两小：
    - 派生类方法的返回值类型小于或等于超类方法的
      - void和基本类型时，必须相等
      - 引用类型时，小于或等于
    - 派生类方法抛出的异常小于或等于超类方法的-------------------API异常之后
  - 一大：
    - 派生类方法的访问权限大于或等于超类方法的**
package和import：
- package：声明包
  - 作用：避免类的命名冲突
  - 同包中的类不能同名，但不同包中的类可以同名
  - 类的全称：包名.类名
  - 建议：包名所有字母都小写，包名常常有层次结构
- import：导入类
  - 同包中的类可以直接访问，但不能包中的类不能直接访问，若想访问：
    - 先import导入类再访问类-----------建议
    - 类的全称---------------------------------太繁琐、不建议

//导入扫描仪
import java.util.Scanner//不同类用import导入类Scanner
Scanner scan = new Scanner (System.in);//调用构造方法Scanner(有参传参)
int age = sacn.nextInt();//调用Scanner构造方法中的nextInt()方法//根据上述推出以下结构
package java.umtil{//有一个叫java.until的包class Scanner{ //一个叫Scanner的类Scanner(System.in){//构造Scanner方法传参(System.in)}int nextInt(){return int}//有一个nextInt方法	}
}

访问控制修饰符：-----------------------保护数据的安全
- public：公开的，任何类
- private：私有的，本类
- protected：受保护的，本类、派生类、同包类------------------------应用率低
- 默认的：什么也不写，本类、同包类--------------------------------------java不建议默认权限
  说明：
  1. 类的访问权限，只能是public或默认的。而类中成员的访问权限，如上4种都可以。
  2. 访问权限由低到高依次为：private<默认的<protected<public
static：静态的
- 静态变量：
  - 由static修饰
  - 属于类，存储在方法区中，只有一份
  - 常常通过类名点来访问
  - 何时用：所有对象所共享的数据(图片、音频、视频等)
- 静态方法：
  - 由static修饰
  - 属于类，存储在方法区中，只有一份
  - 常常通过类名点来访问
  - 静态方法中没有隐式this传递，不能直接访问实例成员
  - 何时用：方法的操作与对象无关(不需要访问对象的属性)
- 静态块：
  - 由static修饰
  - 属于类，在类被加载期间自动执行，因一个类只被加载一次，所以静态块只执行一次
  - 何时用：加载/初始化静态资源(图片、音频、视频等)

笔记：

方法的重写(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异常之后

一大：
- 派生类方法的访问权限大于或等于超类方法的

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

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

public：公开的，任何类
private：私有的，本类(自己类中自己用)
protected：受保护的，本类、派生类、同包类(访问需要自己new对象)------------------------应用率低

默认的：什么也不写，本类、同包类--------------------------------------java不建议默认权限

说明：

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

package ooday04;
//访问控制修饰符的演示
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{ //----------------------演示privatevoid show(){Coo o = new Coo();o.a = 1;o.b = 2;o.c = 3;//o.d = 4; //编译错误}
}package ooday04_vis;
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{ //跨包继承-------演示protectedvoid show(){//继承都是自己的,直接访问,不需要newa = 1;b = 2;//c = 3; //编译错误//d = 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(){ //有thisSystem.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("静态块");//static+{方法区}-----静态块}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();//静态块,构造方法,构造方法,构造方法}
}

补充：

设计规则：数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)
成员变量分为：实例变量和静态变量
- 实例变量：没有static修饰，属于对象，存储在堆中，有几个对象就有几份，通过对象/引用打点来访问
- 静态变量：有static修饰，属于类，存储在方法区中，只有一份，常常通过类名点来访问
内存管理：由JVM来管理的
- 堆：new出来的对象(包括实例变量、数组的元素)
- 栈：局部变量(包括方法的参数)
- 方法区：.class字节码文件(包括静态变量、所有方法)
一般情况下：在静态块中给静态变量赋初始值，在构造方法中给实例变量赋初始值

静态块何时用: 加载/初始化静态资源(图片、音频、视频等), 读取图片速度比文字慢, 所以提高性能