1.instanceof关键字进行类型判断
如何才能知道一个父类引用的对象，本来是什么子类。
格式： 对象 instanceof 类名称
这将得到一个Boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。
//动物类父类
public abstract class Animal {
public abstract void eat();
}
//猫类子类
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃鱼");
}
//子类特有方法
public void catchMouse(){
System.out.println("猫捉老鼠");
}
}
//狗类子类
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃狗粮");
}
public void watchHouse(){
System.out.println("狗看家");
}
}
public class Demo02Instanceof {
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.catchMouse();
}
giveMeApet(new Dog());
}
public static void giveMeApet(Animal animal){
if(animal instanceof Dog){
Dog dog = (Dog) animal;
dog.watchHouse();
}
if (animal instanceof Cat){
Cat cat = (Cat) animal;
cat.catchMouse();
}
}
}
输出结果：
2.笔记本接口项目
//定义USB接口
public interface USB {
public abstract void open();// 打开设备
public abstract void close();// 关闭设备
}
//定义键盘
// 键盘就是一种USB设备
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("键盘输入");
}
}
//定义鼠标
// 鼠标就是一种USB设备
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 Computer {
public void powerOn(){
System.out.println("笔记本电脑开机");
}
public void powerOff(){
System.out.println("笔记本电脑关机");
}
//使用USB设备的方法,使用接口作为方法的参数
public void useDevice(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 DemoMain {
public static void main(String[] args) {
//首先创建一个笔记本电脑
Computer computer = new Computer();
computer.powerOn();
//准备一个鼠标，供电脑使用
Mouse mouse = new Mouse();
//首先进行向上转型，传递进去的就是USB鼠标
USB usb = mouse;//多态写法
computer.useDevice(usb);//参数是USB类型。
//创建USB键盘
Keyboard keyboard = new Keyboard(); // 没有使用多态写法
// 方法参数是USB类型，传递进去的是实现类
computer.useDevice(keyboard);//正确写法，也发生了向上转型。
computer.useDevice(new Keyboard());//正确写法
computer.powerOff();
System.out.println("==================");
method(10.0);//正确写法，double-->double 10.0
method(10);//正确写法，int-->double 10.0
int a = 30;
method(a);//正确写法，int-->double 30.0
}
public static void method(double num){
System.out.println(num);
}
}
输出结果：
3.final关键字
final关键字也是代表最终、不可改变的。
常见四种用法： 1）可以用来修饰一个类 2）也可以用来修饰一个方法 3）还可以用来修饰一个局部变量 4）还可以用来修饰一个成员变量
1.final关键字用于修饰类
当final关键字用来修饰一个类的时候，格式：
public final class 类名称{
//...
}
含义：当前类不能有任何的子类。
注意：一个类如果是final类，那么其中所有的成员方法都无法进行覆盖重写（因为没有子类）
public final class MyClass /*extends Object*/{
public void method(){
System.out.println("方法执行");
}
}
//不能使用一个final类来作为父类
public class MySubClass /*extends MyClass*/ {
}
2.final关键字用于修饰成员方法
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称（参数列表）{
//方法体
}
注意事项： 对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
//定义父类
public abstract class Fu {
public void method(){
System.out.println("父类方法执行");
}
public abstract /*final*/ void methodAbs();
}
//定义子类
public class Zi extends Fu {
@Override
public void methodAbs() {
}
// @Override
// public void method() {
// System.out.println("子类覆盖重写父类的方法");
// }
//错误写法。不能覆盖重写父类当中final的方法
}
3.final关键字用于修饰局部变量
//学生类
public class Student {
private String name;
public Student(){
}
public Student(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class Demo01Final {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1);//10
num1 = 20;
System.out.println(num1);//20
//一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
//一次赋值，终生不变。
final int num2 = 200;
System.out.println(num2);//200
// num2 = 250;//错误写法，不能改变
// num2 = 200;//错误写法
//正确写法，只要保证有唯一一次赋值即可
final int num3;
num3 = 30;
//对于基本类型来说，不可变说的是变量当中的数据不可改变
//对于引用类型来说，不可变说的是变量当中的地址值不可变
Student stu1 = new Student("张靓颖");
System.out.println(stu1);
System.out.println(stu1.getName());//张靓颖
stu1 = new Student("周笔畅");
System.out.println(stu1);
System.out.println(stu1.getName());
System.out.println("==================");
final Student stu2 = new Student("高圆圆");
// stu2 = new Student("霍建华");//错误写法，final引用类型变量，其中的地址值不可改变。
System.out.println(stu2.getName());//高圆圆
stu2.setName("高高圆圆圆");
System.out.println(stu2.getName());//高高圆圆圆
}
}
4.final关键字用于修饰成员变量
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
1）由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值。 2）对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。 3）必须保证类当中所有的重载的构造方法，都最终会对final的成员变量进行赋值。
public class Person {
private final String name/* = "关晓彤"*/;
public Person() {
name = "鹿晗";
}
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
// public void setName(String name) {
// this.name = name;
// }
}
4.四种权限修饰符
Java中有四种权限修饰符： public > protected > (default) > private 同一个类:我自己 可以 可以 可以 可以 同一个包：我邻居 可以 可以 可以 不可以 不同包子类：我儿子 可以 可以 不可以 不可以 不同包非子类：陌生人 可以 不可以 不可以 不可以注意事项：(default)并不是关键字“default”，而是根本不写。
990
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
