java笔记Day07

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();
    }
    
上一篇:嵌套OOPS导致系统卡死 每个CPU都上报softlockup的问题


下一篇:异常处理机制