接着昨天的多态知识点总结:
1.instanceof 对象类型的校验,将返回一个boolean值
Instanceof 对类型进行判断
Animal animal = new Cat();
animal instanceof Cat//判断创建的animal是否为Cat
animal instanceof Dog
对象 instanceof 类型 【将返回一个booean类型】
判断前面的对象,可不可以作为后面类型的实例
对象当中的成员方法—》堆当中的成员方法,保存的是一个【地址值】,指向了方法区的成员方法
例:
givePet(new Dog());
public static void givePet(Animal animal){
if(animal instanceof Dog){//判断animal是不是Dog
Dog dog =(Dog)animal;//进行向下转型
dog.watchHouse();
}
if(animal instanceof Cat){
Cat cat = (Cat)animal;
cat.catchMouse();
}
}
例:useDevice(USB usb);
实现类可以向上转型成为接口类型---》从小到大,自动安全的进行转换
USB usbMouse = new Mouse();//向上转型
lopTop.useDevice(usbMouse);
Keyboard keyboard = new Keyboard();
lopTop.useDevice(keyboard);//从范围小到范围大的,自动安全的进行向上转型
lopTop.useDevice(new Keyboard());
2、final关键字:代表最终的,不可改变的
【1】修饰一个类
格式:
public final class 类名称{
//.....
}
【a】当前这个类(使用final修饰)不能有任何的子类。即不能被继承,但是该类可以向上继承父类
【b】不能使用一个final类来作为父类
【c】使用final修饰后,其中的成员方法不能被覆盖重写,因为没有子类;
public final class MyClass extends Object{
public void methodFinal(){//不能被覆盖重写
System.out.println("final修饰的类");//因为没有子类,所以成员方法不能被覆盖重写
}
}
【2】修饰一个方法
格式:
修饰符 final 返回值类型 方法名称(参数列表){
//方法体
}
public final void methodA(){
System.out.println("用final修饰的成员方法methodA");
}
【注意】当final关键字来修饰一个方法的时候,这个方法就是最终方法,不可以进行覆盖重写;
public class Fu{
public void method(){
System.out.println("父类的成员方法");
}
public final void methodA(){
System.out.println("用final修饰的成员方法methodA");
}
}
public class Zi extends Fu{
public void method(){//子类对父类方法进行了覆盖重写
System.out.println("子类方法");
}
@override//final修饰的方法,子类不能进行覆盖重写,编译会报错
public void methodA(){
System.out.println("用final修饰的成员方法methodA");
}
}
对于类和方法,abstract和final不能同时使用,因为是相互矛盾的;abstract抽象方法必须进行覆盖重写,但是final是不可以进行覆盖重写的,两者在一起使用会冲突;
public abstract void method();//正确写法 子类必须覆盖重写
public final void method(){}//正确写法 因为是最后的方法,不能进行覆盖重写
public abstract final void method(){}//错误写法 abstract是必须进行覆盖,final不能进行覆盖
【3】修饰一个局部变量
使用final进行修饰的局部变量,一旦赋值就不能在改变;只能一次赋值,永不改变;
final int num = 20;
int num = 20;就算再次赋同样的值,也是进行了二次赋值,编译会报错
【注意】
【a】
final int num3;
num3 = 30;//正确写法
//num3先定义在进行赋值,是正确的,如果不赋值,将自动赋值默认值,之后就不可再进行改变,所以使用final修饰的变量必须进行手动的赋值操作;
【b】对于基本数据类型来说,不可变的是变量当中的数值不可变;
对于引用数据类型来说,不可变的是变量当中的地址值不可变;
final Student stu = new Student("A");
stu = new Student("B");//错误写法,final的引用类型变量,其中的地址不可改变
stu.setName("AA");//正确写法 可以赋值
【4】修饰一个成员变量
对成员变量来说,如果使用final关键字进行修饰,那么这个变量也是不可改变的;
【a】由于成员变量具有默认值,一旦用了final之后,必须手动赋值
不会再给默认值了
private final String name;//因为没有进行赋值,默认值为null
【b】对于final的成员变量,要么【使用直接赋值,要么间接通过构造方法赋值】二者选其一;
private final String name = “鹿晗”;//对其进行直接赋值
//this.name = name;setter()方法当中的赋值语句就会报错,因为final修饰的成员变量一旦赋值,就不能改变;
//使用构造方法进行赋值,必须保证所有的构造方法都要进行赋值
//如果是单一赋值,程序会报错
public Person(){
name = “A”;
}
public Person(String name){
this.name = name;
}
//使用了构造方法对final修饰的成员变进行赋值,必须保证所有的构造方法都要对该成员变量进行赋值操作,否则编译报错
【c】必须保证所有的重载的构造方法,都对final修饰的成员变量进行赋值;
3、四种权限修饰符:
default是可以省略的
public > protected > (default) > private
同一类 OK OK OK OK
同一包 OK OK OK
不同包子类 OK OK
不同包非子类 OK
例:同一包不同类之间的访问:
public class MyAnother{
public void antherMethod(){
System.out.println(new MyClass().num);
System.out.println(new MyClass().num1);//报错
}
}
public class MyClass{
int num = 10;
private int num1 = 20
}
4、内部类
一个事物的内部包含另一个事物,那么这就是一个类内部包含另一个类;
【1】成员内部类
成员内部类格式:
修饰符 class 类名称{//外部类
修饰符class类名称{//内部类
}
}
【注意】内用外,随意使用,但是外用内,就需要内部对象
public class Outter{
public class Inner{//定义在方法外,成员内部类
//内部类的方法
public void methodInner()
{
}
}
//外部类的方法
public void methodOutter(){
new Inner.methodInner();//使用内部类的方法
}
}
【2】访问方式
【a】直接访问
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
Outter.Inner methodInnerA = new Outter().new Inner();
methodInnerA.methodInner();
【b】间接访问:通过定义外部类的对象,来调用外部类的成员方法,从而间接的使用内部类的成员方法;
public class DemoInnerClass{
public static void main(String[]args){
Outter outter = new Outter();
outter.methodOutter();
//通过外部类的对象,调用外部的方法,然后里面间接在使用内部类Inner中的方法
}
}
【内类和外部类的字节码文件格式】
Outter.class 外部类class文件
Outter$Inner.class 内部类class文件
【c】内部类的同名变量
public class Outer{
int num = 10;//外部类的成员变量
public class Inner{
int num = 20;//内部类的成员变量
public void methodInner(){
int num = 30;//内部类方法的局部变量
System.out.println(num);//局部变量,就近原则,访问内部类的局部变量
System.out.println(this.num);//内部类的成员变量,访问内部类的成员变量
System.out.prinln(super.num);//错误写法
//因为内外部类之间没有继承关系,不能使用super关键字
System.out.prinln(Outer.this.num);//外部类的成员变量
//外部类名称.this.外部类的成员变量名———— 实现对外部类的成员变量的调用
}
}
}
由于内外部类的知识还没有学习完,明日继续更新这部分的知识点,余留的作业明天做完,整理一下问题笔记,总结之前的知识点,多练习多敲代码。学习之路-共勉 以马内利