零基础入门学习JAVA课堂笔记 ——DAY07

面向对象(下)

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修饰,那么这个类就不能被继承了

零基础入门学习JAVA课堂笔记 ——DAY07

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 一个抽象类,只能靠子类去实现它

零基础入门学习JAVA课堂笔记 ——DAY07

但可以在new的过程中去实现抽象方法

零基础入门学习JAVA课堂笔记 ——DAY07

抽象类是单继承

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;
            }
        }
    }
}
上一篇:Java学习 day07_extends


下一篇:python学习笔记DAY07(编程思想)