面试题总结Java-se

面向对象总结：

1.概念理解：

面向对象是一个比较抽象的概念，面向对象实则就是将数据和对数据操作的方法绑定在一起，形成一个整体。对象当中的一些共性形成了类，在Java中，类中主要有属性和方法，开发当中我们平时说的实例化其实就是将类实例化成为一个对象，通过操作对象当中的属性和方法，完成对象与对象之间的通信。

2.面向对象特性：封装、继承和多态。

封装：在Java当中，我们对类的封装，实则就是对类以及对类中的属性和方法的访问权限进行设置。下图为访问控制权限

以上为访问修饰符《下面为非访问修饰符》

static:用来修饰类方法和类变量，静态变量，静态方法（关于静态方法和非静态方法之间调用问题的深入理解，参考jvm原理教程）

final:用来修饰类、方法和变量

注意：final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的

abstract:用来创建抽象类和抽象方法。

注意：

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract lpf();。代码：

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
         
      }

synchronized:关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。线程同步时用到该关键字，具体理解请学习多线程。

volatile:volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。代码：

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

继承：继承简单的说就是子类继承父类的特征和行为，也可以叫做继承父类的属性和方法，下面显示一个在生活中的继承

 

 为什么要用到继承：子类继承父类就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性 ，并且子类可以在父类的基础上进行扩展。

继承注意点：继承是单继承的，继承一个父类。但是是可以进行多重继承的。（接口当中是支持多继承的）

多态：这里的多态指的是方法得多态，堕胎的产生条件：必须是子类继承了父类，方法进行重写，父类引用指向子类对象。代码理解：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  //定义方法，父类引用指向子类对象
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  //继承
    public void eat() {    //猫重写父类中的方法
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {   //狗重写父类中的方法
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

3.聊聊方法重载与方法的重写

方法的重写是建立在继承的基础上，重写父类中的属性和方法。子类方法和父类的方法名，参数类型，和返回值都是一摸一样的，如果一定要调用父类的方法，我们可以用super关键字来调用。

方法的重载：方法名称相同，参数类型不能相同，参数顺序不能相同，可以有不同的返回值类型

构造方法：不能继承父类的构造方法，系统默认定义无参构造。

instance of:检查是否是a的对象，返回值为boolean类型。。。。。。

1、obj 必须为引用类型，不能是基本类型

1 2 3

int i = 0; System.out.println(i instanceof Integer);//编译不通过 System.out.println(i instanceof Object);//编译不通过

　　instanceof 运算符只能用作对象的判断。

2、obj 为 class 类的实例对象

1 2	Integer integer = new Integer(1); System.out.println(integer instanceof  Integer);//true

　　这没什么好说的，最普遍的一种用法。

3、obj 为 class 接口的实现类

　　了解Java 集合的，我们知道集合中有个上层接口 List，其有个典型实现类 ArrayList

1 2	public class ArrayList<E> extends AbstractList<E>         implements List<E>, RandomAccess, Cloneable, java.io.Serializable

　　所以我们可以用 instanceof 运算符判断 某个对象是否是 List 接口的实现类，如果是返回 true，否则返回 false

1 2	ArrayList arrayList = new ArrayList(); System.out.println(arrayList instanceof List);//true

　　或者反过来也是返回 true

1 2	List list = new ArrayList(); System.out.println(list instanceof ArrayList);//true

4、obj 为 class 类的直接或间接子类

　　我们新建一个父类 Person.class，然后在创建它的一个子类 Man.class

1 2 3

public class Person { }

　　Man.class

1 2 3

public class Man extends Person{       }

　　测试：

1 2 3 4 5 6

Person p1 = new Person(); Person p2 = new Man(); Man m1 = new Man(); System.out.println(p1 instanceof Man);//false System.out.println(p2 instanceof Man);//true System.out.println(m1 instanceof Man);//true

　　注意第一种情况， p1 instanceof Man ，Man 是 Person 的子类，Person 不是 Man 的子类，所以返回结果为 false。

下文详解类：常用类和高级类。。。。