Day11-面向对象03
多态
- 多态是方法的多态,属性没有多态
- 有父类和子类的关系才能转换,不然会出现类型转换异常!ClassCastException!
- 存在条件:继承关系,方法需要重写,父类引用指向子类对象!Father f1=new Son();
不能重写的方法:
- static方法,属于类,不属于实例。
- final常量
- private方法
instanceof关键字
System.out.println("X instanceof Y");//能不能编译通过取决于X和Y有没有父子关系,有就输出true没有就false
类型转换
- 父类引用指向子类的对象
- 把子类转换为父类,向上转型
- 把父类转换为子类,向下转型:强制转换
- 方便方法的调用,减少重复的代码
总结
static关键字
//static
public class Student {
private static int age;//静态的变量
private double score;//非静态的变量
public static void main(String[] args) {
Student s1=new Student();
System.out.println(Student.age);//静态的可以直接用类名调用
System.out.println(s1.age);
System.out.println(s1.score);//而非静态的不行
}
}
静态代码块
public class Person {
//第二执行:和对象同时产生赋初始值
{
System.out.println("匿名代码块");
}
//第一执行:只执行一次
static {
System.out.println("静态代码块");
}
//第三执行
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person p1 =new Person();
System.out.println("============");
Person p2 = new Person();
}
}
输出
静态代码块
匿名代码块
构造方法
============
匿名代码块
构造方法
静态导入包
//静态导入包
import static java.lang.Math.incrementExact;
import static java.lang.Math.random;
public class Test {
public static void main(String[] args) {
System.out.println(random());//导入了静态导入包就不需要写Math.random,可以直接调用
}
}
抽象类
特点:
(抽象的抽象,就是一种约束)
- 抽象类不能new出来,只能靠子类去实现它。(是一种约束,相当于人间的法律)
- 抽象类中可以写普通的方法。
- 抽象方法必须在抽象类中。
package com.oop.p12;
//使用abstract关键字变为抽象类
//类是单继承,而接口是多继承的
public abstract class Action {
public Action() {
}
//约束,有人帮我们实现
//abstract,抽象方法,只有方法名字,没有方法的实现
//抽象类的所有方法都由继承它的子类实现,除非子类也是抽象类,则由子类的子类实现
public abstract void doSomething();
}
总结
接口
interface关键字
package com.oop.p13;
//interface 定义的关键字,接口都需要有实现类
public interface UserService {
//接口定义的属性都是常量,都是public static final
int age=77;
//接口中的所有定义的方法都是抽象的,都是public abstract
void add(int a);
void delete(int b);
void update(int c);
void query(int d);
}
implements关键字
package com.oop.p13;
//类通过implements关键字来实现接口
//实现了接口的类,就需要实现接口中的所有方法
//可以利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
@Override
public void add(int a) {
}
@Override
public void delete(int b) {
}
@Override
public void update(int c) {
}
@Override
public void query(int d) {
}
@Override
public void timer() {
}
}
总结
内部类
Application7类
import com.oop.p14.Outer;
public class Application7 {
public static void main(String[] args) {
Outer outer =new Outer();
//通过这个外部类来实例化内部类
Outer.Inner inner =outer.new Inner();
inner.in();
inner.getID();
}
}
Outer类
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部的方法");
}
//可以获得外部类的私有属性私有方法等
public void getID(){
System.out.println(id);
}
}
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//一个java类中可以有多个class类,但是只能有一个public class
class A{
}
Test类
public class Test {
public static void main(String[] args) {
//没有名字的匿名内部类,不用将实例保存到变量中
new B().C();
}
}
class B{
public void C(){
System.out.println("B");
}
}
interface UserService{
void heelo();
}