面向对象（下）

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;
            }
        }
    }
}