04 面向对象(查漏补缺)

this的作用是什么？都有哪些用途？

表示初始化对象当前本身,内部存在地址,只有创建对象的时候才有this

1.调用成员变量,解决成员变量和局部变量的二义性

public Person(String name, int age) {this.name = name;
//[1] 这是给的创建的对象的字段,不是本类的this,对象创建好了才有这个this//创建对象之前根本就没有thisthis.age = age;}

2.调用其他成员方法,同一个类非static互相调用

public String getName() {
//[2]调用里面的其他非static方法//如果方法名前面没有对象,默认给的thisthis.getAge();//推荐使用return name;}

3.调用其他本类的构造方法(必须写在第一句)

//[3]调用本类的构造方法,需要传入参数
public Person(String nameo,int age,String address) {this("张三",20);//this.address = name;}

super的作用是什么？都有哪些用途？

作用:当子类需要使用父类的某一个功能的时候使用super

1.访问父类的非私有字段

2.访问父类的非私有方法

 public void eat(){System.out.println("吃东西");}

public void dowork() {System.out.println(super.name);super.eat();}

3.访问父类的构造方法

public Animal(String name){//有参构造器this.name = name;}

  public  Rabbit(String name,int age) {//注意写的是构造器,不是书写方法super(name);this.age = age;}

使用super关键字时构造方法必须写在第一句

jvm默认调用无参构造方法

用static修饰的成员和不用static修饰的成员的区别？

static所修饰的成员归类所有,所有的对象都可以访问,没有创建对象时就已经存在

没有被static修饰的成员归对象所有,随着对象的创建而存在

语法:

static 数据类型成员变量 [=初始值]

修饰符 static 返回值类型方法名(){}

访问方式:

类名.静态变量名

类名.静态方法名

示例

public class Car {//非静态变量属于对象对的public static int count;public  Car(){//创建对象时,计数器+1count++;}private String name;public static  int getCount(){//静态方法执行时,对象不存在,属于对象的成员也不能使用//静态方法中不能使用非静态的成员//System.out.println(name);里面报错return count;}
}

public class StaticDemo {public static void main(String[] args) {Car c1=new Car();Car c2=new Car();//对象名.静态变量名System.out.println(c1.count);//里面没有提示
//静态变量的访问的方式
//类名.静态变量名System.out.println(Car.count);//更加直观(推荐)//静态方法的访问方式//类名.静态方法()System.out.println(Car.getCount());//推荐//对象名.静态方法(),(浪费内存)System.out.println(c1.getCount());}
}

final能用在哪些地方，各自的作用是什么？

final修饰的类为最终类,可以修饰类,方法,局部变量,成员变量

保护自己的代码

1.修饰局部变量

修饰基本数据类型时:只能赋值初始化一次不可以重新赋值

修饰引用数据类型时:里面的值可以改变,地址不能变

2.修饰类

被final修饰的类不能被继承

3.修饰方法

被final修饰的方法在子类不能被重写

//final修饰的最终类不能被继承
public /*final*/ class Animal {//final修饰的变量叫常量final int age=20;//定义全局变量并初始化//初始化之后不能再次修改public final void dowork(){//里面的方法不能被子类重写System.out.println(age);final int sno;//可以先定义局部变量sno=20;//再初始化}public static void main(String[] args) {//引用类型的final变量,可以修改引用的对象中的数据,但是地址不能被修改final int[] num={1,2,3,5,674};//num=new int[]{22,33,66,55};已经修改了地址num[0]=111;}
}

说说你对静态代码块的理解

被static关键字修饰的代码块

静态代码块存在于类的内部,方法的外部

静态代码块只执行一次,并且在构造代码块和构造方法前面执行

示例:

public class CodeBlokDemo {{//构造代码块:每次创建对象时,先于构造器执行System.out.println("构造代码块");}public CodeBlokDemo(){System.out.println("构造器");}//将比较耗时间耗资源的代码块放在静态代码块里面,并且在当前类加载到内存中立即执行一次
static{System.out.println("静态代码块");
}public static void main(String[] args) {int num=1;System.out.println(num);{System.out.println(++num);}CodeBlokDemo demo=new CodeBlokDemo();}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-temjq3sM-1684759228494)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230304104128127.png)]

什么时候可以使用匿名内部类？语法是什么？

当一个类只是用一次的时候就将其申明成匿名内部类,匿名内部类必须要有实现存在

//在主板上安装打印机/*      Printer P=new Printer();//重新新建了一个类进行功能的实现,较繁琐mb.plugin(P);
*///如果打印机这个类只需要在这里使用一次,不需要重新新建一个类//创建了一个实现IUSB接口的实现类的对象IUSB P2=  new IUSB(){//接收方法用IUSB@Overridepublic void work() {System.out.println("匿名内部类");}};mb.plugin(P2);}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bFfCVZUi-1684759228496)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230304104756154.png)]

原理:

package cn.wolfcode.匿名内部类;public class inner {//匿名内部类只是用一次,并且作用只是用于实现接口public void print(){/*  class Inner implements Item{//内部类@Overridepublic void say() {System.out.println("匿名内部类");}}
Inner inner=new Inner();inner.say();
*///[1]
//将以上代码转化为匿名内部类new  Item(){//匿名内部类,中间相当于一个实现类,现在重新new并且调用里面的方法@Overridepublic void say() {System.out.println("匿名内部类");}}.say();
//[2]//快捷方式//接口名称 对象名=new 接口名();-->手动添加生成Item item=new Item() {@Overridepublic void say() {}};}
}

ic void say() {
System.out.println(“匿名内部类”);
}
}.say();
//[2]
//快捷方式
//接口名称对象名=new 接口名();–>手动添加生成
Item item=new Item() {
@Override
public void say() {