面向对象(下)
1. Instanceof
我们可以通过Instanceof关键词可以判断当前对象是否为某某类得父类
Object instanceof Student //true
注意:只有是两个类存在父子关系的时候,instanceof才会返回true
package pro;
import pro.Student;
public class App {
public static void main(String[] args){
Object obj = new Student();
System.out.println(obj instanceof Student); //true
System.out.println(obj instanceof Person); //true
System.out.println(obj instanceof String); //false
System.out.println(obj instanceof Teacher); //false
}
}
如果比较两者之间没有一点联系的话在编译的时候就会报错
package pro;
import pro.Student;
public class App {
public static void main(String[] args){
Object obj = new Student();
Student stu = new Student();
System.out.println(obj instanceof Student); //true
System.out.println(obj instanceof Person); //true
System.out.println(obj instanceof String); //false
System.out.println(obj instanceof Teacher); //false
System.out.println(stu instanceof String); //error
}
}
语法规则:X instance Y
- 判断是否才父子关系返回true
- X指向的子类型和Y有关系的也会返回true
2.static
static关键词修饰方法的时候我们称为静态方法
static关键词修饰属性的时候我们称为静态属性
区别:
- 被static修饰的属性或者方法可以直接在main方法内部调用,也可以通过创建创建类的方法调用
- 不被static修饰的属性或者方法只能通过创建类的方法调用
package pro;
import pro.Student;
public class App {
static int num1 = 10;
int num2 = 103;
static void run(){
}
void running(){
}
public static void main(String[] args){
App ap = new App();
System.out.println(ap.num2); //true
System.out.println(ap.num1); //true
num1 = 20; //true
num2 = 20; //error
ap.running(); //true
ap.run(); //true
run(); //true
running()//error
}
}
3.匿名代码块
在Java中可以使用两个花括号来定义一个匿名代码块,如果使用static修饰匿名代码块,那么被修饰的匿名代码块就会在程序开始就创建且只执行一次
package pro;
import pro.Student;
public class App {
{
System.out.println("匿名代码块"); // 2
}
static{
System.out.println("static"); // 1
}
App(){
System.out.println("App"); // 3
}
public static void main(String[] args){
App ap1 = new App();
System.out.println("=======");
App ap2 = new App();
}
}
通过上面的代码我们可以得出,程序运行时,执行的顺序是
静态代码块 =>匿名代码块=>构造器
在第二次创建App对象ap2时,静态代码将不再执行
匿名代码块===>构造器
拓展:静态导入包
可以通过static来修饰类的方法,方便直接调用
package pro;
import static java.lang.Math.random;
public class App {
public static void main(String[] args){
System.out.println(random());
}
}
拓展:final修饰类
如果一个类被final修饰,那么这个类就不能被继承了
3.抽象类
一个比类还抽象的抽象类
在Java中可以通过abstract关键词来修饰类,则类即为抽象类
如果absctrat关键词来修饰方法的话,那么方法为就是抽象方法
package pro;
public abstract class Worker {
public abstract void doSomething();
}
抽象方法:只有定义没有实现,具体的实现由子类来实现
注意:抽象化方法只能在抽象类中定义,子类方法继承抽象类的父类,必须实例化里面的抽象方法,除非子类也是抽象类方法
package pro;
public class Teacher extends Worker{
public void doSomething(){
}
}
不能new 一个抽象类,只能靠子类去实现它
但可以在new的过程中去实现抽象方法
抽象类是单继承
4.接口
普通类:只有具体实现
抽象类:具体事项和规范(抽象方法)都有
接口:只有规范!方法自己写
接口的本质的就是契约!!!
在创建一个Java文件中,可以通过interface去替换闯创建Java文件的class关键词,达到定义接口的效果
package pro;
public interface UserC {
}
接口里面的方法,都是public的抽象类方法
package pro;
public interface UserC {
void add(String temp);
void delete(int id);
void change(int id,String temp);
void search(String temp);
void search(int id);
}
对此可以创建一个类通过implements去继承我们的接口(必须去实现接口中函数的方法)
package jk;
public class UserCImpl implements UserC{
public void add(String name){
}
public void change(int id,String temp){
}
public void delete(int id){
}
public void search(int id){
}
public void search(String name){
}
}
接口不同于抽象类,接口可以实现多继承,可以创建以下接口
package jk;
public interface Time {
void timer();
}
通过前面的例子,通过都好分割实现多接口继承
package jk;
public class UserCImpl implements UserC,Time{
public void add(String name){
}
public void change(int id,String temp){
}
public void delete(int id){
}
public void search(int id){
}
public void search(String name){
}
public void timer(){
}
}
总结
-
约束
-
定义一些方法,让不同的人实现
-
在接口定义的属性,都是常量(一般不这么用)
-
接口不能被实例化 接口中没有构造方法
-
接口可以实现多个接口
- 必须要重写接口的方法
5.Java内部类
在一个类的内部再写一个类就叫内部类
内部类
在Java中我们可以在一个类的内部在创建一个类,可以通过外部类方法去new一个外部类中的内部类
package outerClass;
import java.sql.SQLOutput;
//这是外部类
public class Outer {
private int id = 10;
public void say(){
System.out.println("这是外部类");
}
//这是内部类
public class In{
public void main(){
System.out.println("这是内部类");
}
public void getId(){
System.out.println(id); //id?
}
}
}
创建一个App的主方法去创建new一个In对象
package outerClass;
public class App {
public static void main(String[] args) {
Outer outer = new Outer();
Outer.In in = outer.new In();
}
}
根据上例代码,我们发现为什么In这个类里面的getId方法这么写也不会报错?
内部类的一个很重要的属性:可以访问外部类私有的方法
静态内部类
在原有的内部类的情况下 通过static修饰,就叫静态外部类。
静态外部类不能访问私有的属性,除非是静态属性
(此处省略一亿八千三百六十五万三千零就是行)
局部内部类
在方法内部定义的类,称之为具备局部内部类
package outerClass;
public class App {
public static void main(String[] args) {
class app{
private int id = 0;
public void setId(int ids){
this.id = ids;
}
}
}
}