Java 个人总结 4

对象

三大特性

封装、继承、多态

面向对象

.以类的方式组织代码，以对象的组织（封装）数据

对象内存分析

多态

存在条件

1. 有继承关系
2. 子类重写父类方法
3. 父类引用指向子类对象

注意

多态是方法的多态，属性没有多态性

instanceof

功能：判断前面的对象是否属于后面的类，或者属于其子类。

Object是所有类的父类

代码块

public class CodeBlock {
    //匿名代码块
    // 一般用于赋初值
    // 每创建一次对象 运行一次
    {
        System.out.println("匿名代码块");
    }
    //静态代码块
    //类加载后运行，只运行一次
    static {
        System.out.println("静态代码块");
    }
    public CodeBlock(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        CodeBlock codeBlock = new CodeBlock();
        System.out.println("-------------------------");
        CodeBlock codeBlock2 = new CodeBlock();
        /*
        静态代码块
        匿名代码块
        构造方法
        -------------------------
        匿名代码块
        构造方法
         */
    }
}

抽象

.抽象的抽象：约束

1. 抽象类不能new，只能靠子类去实现;
2. 抽象类中可以写普通方法;
3. 抽象方法必须在抽象类中.

定义/声明

public abstract class UAbstract {
    public abstract void run();
    public abstract void say();
    public void all(){
        run();
        say();
    }
}

使用

public class UAbstract2 extends UAbstract{
    @Override
    public void run() {
        System.out.println("run");
    }

    @Override
    public void say() {
        System.out.println("say");
    }

    public static void main(String[] args) {
        UAbstract uAbstract = new UAbstract2();
        uAbstract.all();
        /*
            run
            say
         */
    }
}

意义：提高开发效率。

接口

1. 是一种约束；
2. 定义一些方法，让不同的人实现；
3. 接口不能被实例化；
4. 接口可以实现多个；
5. 类实现接口后，必须要重写接口中的方法。

内部类

概念

在一个类的内部再定义一个类。

分类

1. 成员内部类

2. 静态内部类

   //外部类
   public class Outer {
   
       private int id=6;
       public void out(){
           System.out.println("外部类的方法");
       }
   
       //内部类
       public class Inner{
           public void InnerFunction(){
               System.out.println("内部类的方法");
           }
   
           //获得外部类的私有属性
           public void InnerGetOuterId(){
               System.out.println(id);
           }
       }
   
       //静态内部类 用static修饰
       //不能访问Outer的属性
       public static class StaticInner{
           public void InnerFunction(){
               System.out.println("内部类的方法");
           }
   
           //获得外部类的私有属性
           public void InnerGetOuterId(){
   //            System.out.println(id); //报错
           }
       }
   }
   
   

3. 局部内部类

   public class Outer2 {
       public void method(){
           //局部内部类
           //放在方法里
           class Inner{
   
           }
       }
   }
   

4. 匿名内部类

   public class Outer4 {
       public static void main(String[] args) {
           //匿名内部类
           UserService3 userService3 = new UserService3() {
               @Override
               public void hello() {
                   System.out.println("Hello");
               }
           };
           userService3.hello();
       }
   }
   interface UserService3{
       void hello();
   }
   

其他

1. 一个java文件中可以有多个class类，但只能有一个public class;