java笔记

对象的向上转型

1.对象的向上转型。其实就是多态写法:

格式:父类名称 对象名 = new 子类名称(); Animal animal = new Cat();

含义:右侧创建—个子类对象,把它当做父类来看待使用。 创建了一只猫,当做动物看待,没问题。

注意事项:向上转型一定是安全的。从小范围转向了大范围,从小范围的猫,向上转换成为更大范围的动物。

类似于:

double num = 100; //正确,int --> double,自动类型转换。

对象的向下转型

2.对象的向下转型,其实是一个【还原】的动作。

格式:子类名称 对象名 =(子类名称) 父类对象; Cat cat = (Cat) animal;

含义:将父类对象,【还原】成为本来的子类对象。 本来是猫,已经被当做动物了,还原回来成为本来的猫

注意事项:

a.必须保证对象本来创建的时候,就是猫,才能向下转型成为猫。

b.如果对象创建的时候本来不是猫,现在非要向下转型成为猫。就会报错。

类似于:

int num =(int)10.0;//可以 int num =(int)10.5//精度损失

public abstract class Animal {
    public abstract  void eat();
​
}
==============================================
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void catchMouser(){
        System.out.println("猫抓老鼠");
    }
}
===============================================
public class Demo01Man {
    public static void main(String[] args) {
        //对象的向上转型,就是:父类引用指向之类对象
        Animal animal = new Cat();
        animal.eat();//猫吃鱼
        //animal.catchMouser(); 错误写法!
​
        //向下转行,进行“还原”动作
        Cat cat = (Cat) animal;
        cat.catchMouser();//猫抓老鼠
        //下面是错误的向下转型
        //本来new的时候是一只猫,现在非要当中狗
        //错误写法!编译不会报错,但是运行会出现异常,
        // java.lang.ClassCastException  类转换异常
        Dog dog = (Dog) animal;
    }
}
=================================================
public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void watchHouse(){
        System.out.println("狗看家");
    }
}

用instanceof关键字进行判断

public class Demo01Instanceof {
    public static void main(String[] args) {
        Animal animal = new Cat();//本来是一只猫
        animal.eat();//猫吃鱼
        //如果希望调用子类特有方法,需要向下转型
        //判断一下父类引用animal本来是不是Dog
        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        //判断一下父类引用animal本来是不是Cat
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouser();
        }
        Dexter(new Dog());
    }
    public static void Dexter(Animal animal){
        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        //判断一下父类引用animal本来是不是Cat
        if(animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.catchMouser();
        }
    }
}
猫吃鱼
猫抓老鼠
狗看家

接口多态的综合案例USB

public interface USB {
    public abstract void open();//打开设备
    public abstract void close();//关闭设备
}
public class Computer {
    public void powerOn(){
        System.out.println("笔记本电脑开机");
    }
    public void powerOff(){
        System.out.println("笔记本电脑关机");
    }
    //使用USB设备的方法,使用接口作为方法的参数
    public void userDevice(USB usb){
        usb.open();
        if(usb instanceof Mouse){//先判断
            Mouse mouse = (Mouse) usb;//向下转型
            mouse.click();
        }else if(usb instanceof Keyboard){//先判断
            Keyboard keyboard = (Keyboard) usb;//向下转型
            keyboard.type();
        }
        usb.close();
    }
}
public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }
​
    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }
    public void click(){
        System.out.println("鼠标点击");
    }
}
public class Keyboard implements USB{
    @Override
    public void open() {
        System.out.println("打开键盘");
    }
​
    @Override
    public void close() {
        System.out.println("关闭键盘");
    }
    public void type(){
        System.out.println("键盘输入");
    }
}
​
public class DemoMain {
    public static void main(String[] args) {
        //首先创建一个笔记本电脑
        Computer computer = new Computer();
        computer.powerOn();
        //首先进行向上转型
        USB usbMouse = new Mouse();//多态写法
        //参数是USB类型,传递进去的就是USB鼠标
        computer.userDevice(usbMouse);
        //首先创建一个USB键盘
        Keyboard keyboard  = new Keyboard();//没有使用多态写法
        //参数是USB类型,传递进去的是实现类对象
        computer.userDevice(keyboard);//正确写法,也是向上转型
        computer.userDevice(new Keyboard());//也是正确写法
        computer.powerOff();
    }
}

final 关键字

final关键字代表最终、不可改变的。

常见四种用法:

1.可以用来修饰一个类

2.可以用来修饰一个方法

3中还可以用来修饰一个局部变量

4.还可以用来修饰─个成员变量

final 关键字用来修饰一个类

格式:

public final class 类名称 {
    //.......
}

含义:当前这个类不能有任何的子类。

注意:一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写(因为没子类)

final 关键字用来修饰成员方法

当于final关键字用来修饰一个方法的时候,这个方法就是最终方法,也就是不能被覆盖重写。

格式:

修饰符 final 返回值类型 方法名称(参数列表) {
    //方法体
}

注意事项:

对于类、方法来说, abstract关键字和final关键字不能同时使用,因为矛盾。

public abstract final void method(); 
//错误写法 abstract 就是要被覆盖重写  而fianl就是不能被覆盖重写

final 关键字用来修饰局部变量

对于基本类型来说,不可变说的是变量当中的数据不可改变

—旦使用finaL用来修饰局部变量,那么这个变量就不能进行更改。
“一次赋值,终生不变”
final int num1 = 200;
System.out.println(num1);//200
num1 = 250;//错误写法
num1 = 200; //错误写法

对于引用类型来说,不可变说的是变量当中的地址值不可改变

final Student stu1 = new Student("张艺兴")
    //错误写法 fianl的引用类型变量,其中的地址不可改变
    //stu1 = new Student("张子枫");
	System.out.println(stu1.getname());//张艺兴
	stu1.setName("张子枫");
	System.out.println(stu1.getname());//张子枫

final 关键字用来修饰成员变量

对于成员变量来说,如果使用final关键字修饰,那么这个变量也照样是不可变。

1.由于成员变量具有默认值,所以用了final之后必须手动赋值,不会再给默认值了。

2.对于final的成员变量,要么使用直接赋值,要么通过构造方法赋值。二者选其一。

3.必须保证类当中所有重载的构造方法,都最终会对于final的成员变量进行赋值。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java笔记是由北京大学青鸟教育推出的一款专门针对Java语言的学习工具。它以全面、系统、实践为特点,通过详细的代码示例和清晰的讲解,帮助学习者全面掌握Java编程语言。 Java笔记采用了线上与线下相结合的学习模式。学员可以通过手机、平板电脑、电脑等设备在线学习,还可以在学习过程随时记录自己的学习笔记。同时,北大青鸟还为学员提供线下实践环境,学员可以在实验室里亲自动手实践所学知识,加深理解和应用。 Java笔记的内容非常全面,包括了Java语言的基本语法、面向对象编程、异常处理、流操作、多线程、数据库操作等众多知识点。除了理论知识,Java笔记还提供了大量的实例代码,可供学员参考和模仿。这样的学习方式既帮助学员理解Java的基本概念,又能让他们运用所学知识解决实际问题。 与此同时,Java笔记还注重学员的互动交流。在学习过程,学员可以利用笔记功能记录学习心得和疑惑,还可以在论坛上与其他学员进行讨论和交流。这种互动形式既能促进学员之间的学习互助,也能更好地帮助学员理解和应用所学知识。 总之,Java笔记是北大青鸟推出的一款专注于Java语言学习的工具,通过系统的课程设置、丰富的实例代码和互动交流的方式,帮助学员全面掌握Java编程知识,提升编程能力。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值