1.方法的重写(Override):
重新写、覆盖。
1)发生在父子类中,方法名称相同,参数列表相同,方法体不同。
2)重写方法被调用时,看对象的类型
2.重写与重载的区别:---------常见的面试题1)重写(Override):
1.1)发生在父子类中,方法名称相同,参数列表相同,方法体不同。
1.2)遵循"运行期绑定",看对象的类型调用方法。
2)重载(Overload):
2.1)发生在同一类中,方法名称相同,参数列表不同,方法体不同
2.2)遵循"编译期绑定",看引用的类型绑定方法。
3.package:
1)作用:避免类的命名冲突
2)包一般都是有层次结构的
3)类名的全称为: 包名.类名
4)建议:包名所有字母都小写
import:
1)同一个包中的类可以直接访问,
不同包中的类不能直接访问,想访问有两种方式:
1.1)先import声明类再直接访问----建议
1.2)类的全称---------------------太繁琐,不建议
4.访问控制修饰符:
1)public:公开的,任何类
2)private:私有的,本类
3)protected:受保护的,本类、子类、同包类
4)默认的:什么也不写,本类、同包类
类的访问修饰为: public和默认的
类中的成员的访问修饰为:如上4种都可以
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
default √ √ × ×
private √ × × ×
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)修饰类:类不可被继承
package oo.day04; //static的演示 public class StaticDemo { public static void main(String[] args) { Loo o1 = new Loo(); o1.show(); Loo o2 = new Loo(); o2.show(); System.out.println(Loo.b); //建议类名点来访问 //System.out.println(o1.b); //不建议通过对象来访问 Moo.test(); Noo o3 = new Noo(); Noo o4 = new Noo(); Noo o5 = new Noo(); } } class Noo{ //演示静态块 Noo(){ //创建对象时被自动执行 System.out.println("构造方法"); } static{ //类被加载时自动执行 System.out.println("静态块"); } } class Moo{ //演示静态方法 int a; static int b; void show(){ //有隐式的this System.out.println(+a); //this.a System.out.println(b); //Moo.b } static void test(){ //没有隐式的this //静态方法没有隐式的this, //没有this就意味着没有对象, //而实例成员必须通过对象来访问 //静态方法中不能直接访问实例成员 //System.out.println(a); //编译错误 System.out.println(b); //Moo.b } } class Loo{ //演示静态变量 int a; //实例变量 static int b; //静态变量 Loo(){ a++; b++; } void show(){ System.out.println("a="+a); System.out.println("b="+b); } }
package oo.day04; //final的演示 public class FinalDemo { public static void main(String[] args) { } } //演示final修饰类 final class Roo{} //class Soo extends Roo{} //编译错误,final的类不可被继承 class Too{} final class Uoo extends Too{} //演示final修饰方法 class Poo{ void show(){} final void test(){} } class Qoo extends Poo{ void show(){} //void test(){} //编译错误,final的方法不可被重写 } /* * final修饰成员变量,两种初始化方式: * 1)声明的同时初始化 * 2)在构造方法中初始化 * final修饰局部变量,用之前初始化即可 */ class Ooo{ //演示final修饰变量 final int a = 5; final int b; Ooo(){ b = 6; } void show(){ final int c; //a = 55; //编译错误,final的变量不可被改变 } }
package oo.day04; //重写的演示 public class OverrideDemo { public static void main(String[] args) { /* Boo o1 = new Boo(); o1.show(); //子show Aoo o2 = new Boo(); //向上造型 o2.show(); //子show */ //重载看引用类型,重写看对象类型 Goo goo = new Goo(); Eoo o = new Foo(); //向上造型 goo.test(o); //重载看引用的类型(Eoo)绑定方法 } } class Goo{ void test(Eoo o){ System.out.println("父型参数"); o.show(); //重写看对象的类型(Foo)调用方法 } void test(Foo o){ System.out.println("子型参数"); o.show(); } } class Eoo{ void show(){ System.out.println("父类show"); } } class Foo extends Eoo{ void show(){ System.out.println("子类show"); } } /* * 重写要遵循"两同两小一大"原则: * 1)两同: * 1.1)方法名相同 * 1.2)参数列表相同 * 2)两小: * 2.1)子类方法的返回值类型小于或等于父类的 * 2.1.1)void时,必须相同 * 2.1.2)基本类型时,必须相同 * 2.1.3)引用类型时,小于或等于 * 2.2)子类方法抛出的异常小于或等于父类的------异常之后 * 3)一大: * 3.1)子类方法的访问权限大于或等于父类的---访问控制修饰符后 */ //父类大,子类小 class Coo{ void show(){} double say(){return 0.0;} Doo sayHi(){return null;} public Coo test(){return null;} } class Doo extends Coo{ //int show(){return 1;} //编译错误,void时必须相同 //int say(){return 0.0;} //编译错误,基本类型时必须相同 //Coo sayHi(){return null;} //编译错误,引用类型必须小于或等于 public Doo test(){return null;} } class Aoo{ void show(){ System.out.println("父类show"); } } class Boo extends Aoo{ void show(){ System.out.println("子类show"); } }
package oo.day04; //J型 public class J extends Tetromino { J(){ this(0,0); } J(int row,int col){ super(); cells[0] = new Cell(row,col); cells[1] = new Cell(row+1,col); cells[2] = new Cell(row+2,col-1); cells[3] = new Cell(row+2,col); } void print(){ //输出4个格子的行号和列号 System.out.println("I am a J:"); super.print(); } }
package oo.day04; //T型 public class T extends Tetromino { T(){ this(0,0); } T(int row,int col){ super(); //默认--调用父类的无参构造方法 super.cells[0] = new Cell(row,col); //创建Cell对象 super.cells[1] = new Cell(row,col+1); super.cells[2] = new Cell(row,col+2); super.cells[3] = new Cell(row+1,col+1); } void print(){ //输出4个格子的行号和列号 System.out.println("I am a T:"); super.print(); //调用父类的print()方法 } }
package oo.day04; //四格拼板 public class Tetromino { Cell[] cells; //格子数组 Tetromino(){ cells = new Cell[4]; //创建Cell数组对象 } void drop(){ for(int i=0;i<this.cells.length;i++){ this.cells[i].row++; } } void moveLeft(){ for(int i=0;i<this.cells.length;i++){ this.cells[i].col--; } } void moveRight(){ for(int i=0;i<this.cells.length;i++){ this.cells[i].col++; } } void print(){ //输出4个格子的行号和列号 for(int i=0;i<this.cells.length;i++){ String str = this.cells[i].getCellInfo(); System.out.println(str); } } }
package oo.day04; //T型与J型的测试类 public class TJTest { public static void main(String[] args) { Tetromino t = new T(2,5); t.print(); Tetromino j = new J(1,4); j.print(); } //打墙+打T形 public static void printWall(Tetromino t){ //效率低、扩展性好 for(int i=0;i<20;i++){ for(int j=0;j<10;j++){ boolean flag = false; //1.假设打- for(int k=0;k<t.cells.length;k++){ if(i==t.cells[k].row && j==t.cells[k].col){ flag = true; //2.修改为打* break; } } if(flag){ //3.判断得结果 System.out.print("* "); }else{ System.out.print("- "); } } System.out.println(); } } }