Java学习笔记_多态/内部类

多态的格式与使用
代码当中体现多态性，其实就是一句话，父类引用指向子类对象

格式：
父类名称对象名 = new 子类名称();
或者
接口名称对象名 = new 实现类名称();

public class Demo{public static void main(String[] args){//使用多态写法//左侧父类的引用，指向了右侧子类对象Fu obj = new Zi();obj.method();obj.methodFu();}
}

多态中成员变量的使用特点
访问成员变量的两种方式：

直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找
间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找

public class Demo{public static void main(String[] args){//使用多态写法//左侧父类的引用，指向了右侧子类对象Fu obj = new Zi();System.out.println(obj.num);//父：10System.out.println(obj.age);//错误写法//子类没有覆盖重写，就是父//子类如果覆盖重写，就是子obj.showNum();}
}

多态中成员方法的使用特点
在多态的代码当中，成员方法的访问规则是：
看new的是谁，就优先用谁，没有则向上找
口诀：编译看左边，运行看右边

成员变量：编译看左边，运行还看左边
成员方法：编译看左边，运行看右边

public class Demo{public static void main(String[] args){//使用多态写法//左侧父类的引用，指向了右侧子类对象Fu obj = new Zi();//多态obj.method();//父子都有，优先用子obj.methodFu();//子类没有，父类有，向上找到父类//编译看左边，左边是Fu，Fu当中没有methodZi方法，编译报错//obj.methodZi(); //错误写法

instantceof关键字
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容

解决方案：用对象的向下转型还原

public class Demo{public static void main(String[] args){//对象的向上转型，就是父类引用指向子类对象Animal animal = new Cat();//本来创建的时候是一只猫animal.eat();//猫吃鱼//       animal.catchMouse();//错误写法//向下转型，进行“还原”动作Cat cat = （Cat） animal;cat.catchMouse();//猫抓老鼠
}

如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到有个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例

public class Demo{public static void main(String[] args){Animal animal = new Cat();//本来是一只猫animal.eat();//猫吃鱼//如果希望调用子类特有的方法，需要向下转型//判断一下父类引用animal本来是不是Dogif(animal instanceof Dog){Dog dog = (Dog) animal;dog.watchHouse();}//判断一下animal本来是不是catif(animal instanceof Cat){Cat cat = (Cat) animal;cat.catchMouse();}}
}

final关键字用于修饰类
当final关键字用来修饰一个类的时候，格式：
public final class 类名称{
//…
}

含义：当前这个类不能有任何子类
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写

public final class MyClass{public void method(){System.out.println(“方法执行”)；}
}

final关键字修饰成员方法
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写
格式：
修饰符 final 返回值类型方法名称（参数列表）{
//方法体
}

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾

public abstract /*final*/ void methodAbs();

final关键字修饰局部变量
final关键字代表最终的、不可改变的

常见的四种用法：

可以用来修饰一个类
可以用来修饰一个方法
可以用来修饰一个局部变量
可以用来修饰一个成员变量

public class Demo{public static void main(String[] args){int num1 = 10;System.out.println(num1);num1 = 20;System.out.println(num1);//一旦使用final修饰局部变量，那么这个变量就不能更改final int num2 = 200;System.out.println(num2);//num2 = 250; //错误写法，不可修改final int num3;num3 = 300;//对于基本类型来说，不可改变的是变量当中的数据不可改变//对于引用类型来说，不可变说的是变量当中的地址值不可改变Student stu1 = new Student(name:”zhangsan”);System.out.println(stu1);System.out.println(stu1.getName());final Student stu2 = new Student(name:”lisi”);System.out.println(stu.getName());stu2.setName(“wangwu”);System.out.println(stu2.getName());}}

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

由于成员变量具有默认值，所以使用了final之后必须手动赋值，不会再给默认值
对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值
必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值

public class Person{private final String name;public Person(){name = “zhangsan”;}
}

成员内部类

成员内部类的定义格式

修饰符 class 外部类名称{
修饰符 class 内部类名称{
// …
}
// …
}

注意：内用外，随意访问；外用内，需要内部类对象

使用成员内部类的方式：

间接访问：在外部类当中访问，使用内部类；然后main只是调用外部类的方法
直接方式：公式类名称对象名 = new 类名称();
外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();

public class Demo{public static void main(String[] args){Body body = new Body();//通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heartbody.methodBody();Body.Heart heart = new Body().new Heart();heart.beat();}
}

内部类的同名变量访问
如果出现了重名现象，那么格式是：外部类.this.外部类成员变量名

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.println(Outer.this.num);//外部类的成员变量}}
}

局部内部类的定义
定义格式：
修饰符 class 外部类名称 {
修饰符返回值类型外部类方法名称(参数列表{
class 局部内部类名称{
// …
}
}
}

局部内部类的final问题

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是有效final的
备注：从Java8开始，只要局部变量事实不变，那么final关键字可以省略

匿名内部类
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次
那么这种情况下就可以省略掉该类的定义，而改为使用匿名内部类

匿名内部类的定义：
接口名称对象名 = new 接口名称(){
//覆盖重写所有抽象方法
}

public class Demo{public static void main(String[] args){//MyInterface obj = new MyInterfaceImpl();//obj.method();//MyInterface some = new MyInterface();//使用匿名内部类MyInterface obj = new MyInterface(){public void method(){System.out.println(“匿名内部类实现了方法”)；}}；obj.method;}
}

匿名内部类，在创建对象时，只能使用唯一一次
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类
匿名对象，在调用方法的时候，只能调用唯一一次
如果希望同一个对象，调用多次方法，那么必须给对象起个名字
匿名内部类是省略实现类/子类名称，但是匿名对象是省略了对象名称

Java学习笔记_多态/内部类相关推荐

JAVA学习笔记_银行账户系统
大家好,我是一枚JAVA学习的小白,初次来到SCND还请多多指教!!!! 最近上编程课学习都挺晚的,没时间逛论坛了,今天休息正好也赶上线上,所以来发点学习笔记,一起讨论学习.(看我这个标点符号就知道我 ...
Java学习笔记:04面向对象-内部类_访问修饰符_final
04面向对象-内部类/访问修饰符/final 1.static的介绍 static:关键字,静态的 static的作用是用来修饰类中的成员 2.访问一个类中的某一个成员变量方法一: _1.创建对象 ...
马士兵 java 学习笔记_马士兵java教程笔记1
---恢复内容开始--- 前记虽然已经是个研究生了,但是会的东西还是特别的少甚至连java都不能说是很会所以准备从现在开始能好好的学习java 变成java master 标识符标识符是由字母 ...
Java学习笔记_类和对象
·类:是一组相关属性和行为的集合,可以看成是一类事务的模板,使用事物的属性特征和行为特征来描述该类事物. ·属性:该事物的状态信息 ·行为:就是该事物能够做什么 ·对象:一类事物的具体体现,对象是类的 ...
java学习笔记day06---匿名内部类
1.匿名内部类:其实就是内部类的简化形式,它所体现的就是一个类或者接口的子类对象. 前提: 内部类必须继承或实现外部类或接口. 格式: new 父类&接口(){}; ...
Java学习笔记_抽象/接口
抽象方法:就是加上abstract关键字,然后去掉大括号,直接分号结束抽象类:抽象方法所在的类,必须是抽象类.在class前面写上abstract 如何使用抽象类和抽象方法不能直接创建new抽象类 ...
Java学习笔记_继承
继承的格式在继承关系中,"子类就是一个父类".也就是说,子类可以被当作父类看待例如父类是员工,子类是讲师,那么"讲师就是一个员工" 定义父类的格式:(一个普 ...
Java学习笔记_字符串/静态static
字符串的特点字符串的内容永不可变正是因为字符串不可改变,所以字符串是可以共享使用的字符串效果上相当于是char[]字符数组,但是底层原理是byte[]字节数组创建字符串的常见3+1种方式三种 ...
Java学习笔记_匿名/ArrayList
引用类型的一般使用步骤: 导包 import 包路径.类名称如果需要使用的目标类,和当前类位于同一个包下,则可以省略导包语句不写只有java.lang包下的内容不需要导包,其它的包都需要impor ...

Java学习笔记_多态/内部类

Java学习笔记_多态/内部类相关推荐

最新文章

热门文章