instanceof和类型转换
//Object->Person->Student
//Object->Person->Teacher
//Object->String
//高 低
Object obj = new Student();
//System.out.println(x instanceof y);//能否编译成功却决于x和y是否具有父子关系
System.out.println(obj instanceof Person);//true
System.out.println(obj instanceof Student);//true
System.out.println(obj instanceof Object);//true
System.out.println(obj instanceof String);//false
System.out.println(obj instanceof Teacher);//false
System.out.println("=====================");
Person person = new Student();
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Object);//true
//System.out.println(person instanceof String);//编译报错!
System.out.println(person instanceof Teacher);//false
System.out.println("==========================");
Student student = new Student();
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof String);//编译报错!
//System.out.println(student instanceof Teacher);//编译报错!
类型之间的转化
//高 ------------- 低(低转高不需要强制转换)
Person person = new Student();
//Student将这个对象转换为Student类型,就可以使用Student类型的方法了!
//高转低需要强制转换
//((Student)person).hello();
Student student = (Student)person;
student.hello();
//子类转换为父类可能丢失自己本来的一些方法
static关键字
static静态的
静态变量
static int a = 3;
静态变量和非静态变量的区别是:静态变量被所有对象共享,且内存中只有一个副本,类初始加载时被初始化;非静态变量是对象所拥有的,创建对象的时候被初始化,存在多个副本,各个对象拥有的副本互不影响。
静态方法
public static void run(){}
静态方法不依赖对象就可以访问,静态方法不能访问类的非静态成员变量和方法,因为非静态成员变量和方法必须依赖对象调用。非静态成员变量和方法可访问静态成员变量和方法。
静态代码块
static{
int a= 3;
int b = 4;
}
static代码块可以放在类中的任何地方,类中可以有多个static代码块,在类被初次加载,按照static的顺序执行每个static代码块,且只执行一次。可以优化程序性能。
静态导入包
import static java.lang.Math.random
import static java.lang.Math.PI
double a = random();
抽象类
abstract修饰符可以用来修饰方法也可以修饰类
抽象方法
public abstract void run();
抽象类
public abstract class Action{}
抽象类中可以没有抽象方法,但是又抽象方法的一定要声明为抽象类。
抽象类不能用new关键字来创建对象,它是用来让子类继承的。
抽象方法只有方法的声明没有方法的实现,方法让子类来实现。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则子类也要声明为抽象类。
抽象类中存在构造方法
抽象类可以有构造方法,只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。
接口
普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范!自己无法写方法–专业的约束!约束和实现分离:面向接口编程
接口的本质是契约。
声明接口的关键字是interface
UserService.java
//interface接口定义关键字,接口都需要有实现类
public interface UserService {
//接口中定义的都是常量public static final
int AGE = 99;
//接口中所有定义的都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
TimerService.java
public interface TimerService {
void timer();
}
UserServiceImpl.java
//类 可以实现接口 implements 接口
//实现了接口的类就需要重写接口中的方法
//多继承,利用接口多继承
public class UserServiceImpl implements UserService,TimerService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
内部类
内部类就是在一个类的内部定义一个类,比如,A类中定义一个B类,那么B类相对A类来说就称为内部类,而A类相对B类来说就是外部类。
-
1.成员内部类
public class Outer { public static void main(String[] args) { Outer outer = new Outer(); //通过外部类来实例化内部类 Outer.Inner inner = outer.new Inner(); inner.getId(); } 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); } } } //也是内部类 class S{ }
-
2.静态内部类
public class Outer2 { public static void main(String[] args) { Outer2 outer = new Outer2(); } private int id = 10; public void out(){ System.out.println("这是外部类的方法!"); } public static class Inner { public void in() { System.out.println("这是内部类的方法!"); } } }
-
3.局部内部类
public class Outer2 { public static void main(String[] args) { Outer2 outer = new Outer2(); } private int id = 10; public void out(){ System.out.println("这是外部类的方法!"); } public static class Inner { public void in() { System.out.println("这是内部类的方法!"); } } //局部内部类 public void method(){ //方法中也可以写内部类 class V{ public void v(){} } } }
-
4.匿名内部类
public class Test { public static void main(String[] args) { //没有名字去初始化类,不用将实例保存到变量中 new Apple().eat(); //匿名内部类 PersonService personService = new PersonService() { @Override public void hello() { System.out.println("hello"); } }; } } class Apple{ public void eat(){ System.out.println("吃个苹果!"); } } interface PersonService{ void hello(); }