4 面向对象

1 成员变量和局部变量的区别

A:在类中的位置不同
　　成员变量：在类中方法外
　　局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
　　成员变量：在堆内存(成员变量属于对象,对象进堆内存)
　　局部变量：在栈内存(局部变量属于方法,方法进栈内存)
C:生命周期不同
　　成员变量：随着对象的创建而存在，随着对象的消失而消失
　　局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
　　成员变量：有默认初始化值
　　局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

注意事项：
　　局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
　　基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char
　　引用数据类型变量包括哪些:数组,类,接口,枚举

2 static关键字的特点

1.随着类的加载而加载

2.优先于对象存在

3.被类的所有对象共享--------一个对象改变了其值,其余对象在访问时其值以变化

4.可以通过类名调用

　　其实它本事可以通过对象名调用,推荐使用类名调用,

　　静态修饰的内容我们一般称其为:与类相关的,类成员

共性用静态,特性用成员变量.

 

3 代码块

1.在java中,用{}括起来的代码称为代码块.

2.根据其位置和声明不同,分为局部代码块,构造代码块,静态代码块,通过代码块(多线程讲解)

　　1.局部代码块:在方法中出现,限定变量生命周期,及早释放,提高内存利用率

　　2.构造代码块(初始化块):在类中方法外出现,在构造方法执行前执行.

　　3.静态代码块:在类中方法外出现,并加static修饰,用于给类进行初始化,在加载的时候就执行,并且只执行一次.

 静态代码块>构造代码块>构造方法

将字节码加载到方法区的时候,静态代码块就会执行.一般用于加载驱动. 

 

4 父类没有无参构造时

1.子类在new 对象的时候,会默认访问父类的空参构造,当父类无空参构造时,需要手动使用super语句访问父类的有参构造.

2.super语句必须放在构造方法的第一句.

public class T6 {
    public static void main(String[] args) {
        Cat c = new Cat("green",4);
        System.out.println(c.getColor());
        
    }
}

class Animal{
//    public Animal(){
//        System.out.println("父类构造");
//    }
    String color;
    int legs;
    
    public Animal(String color,int legs){
        this.color = color;
        this.legs = legs;
    }
    
    public String getColor(){
        return this.color;
    }
    
    
}

class Cat extends Animal{
//    public Cat(){
//        System.out.println("子类构造");
//    }
    
    public Cat(String color,int legs){
        super(color,legs);
    }
    
}

 

 5.构造代码块构造方法面试题

public class T7 {
    public static void main(String[] args) {
        Zi f = new Zi();
        /**
         * 1.main方法进栈,因为要创建对象所以会先加载class文件到方法区,父类先加载然后子类再加载
         * 2.new Zi()时,先访问父类的空参构造,父类构造代码块先执行然后再执行父类构造方法
         * 3.完毕后,再访问子类构造代码块,再访问子类构造
         * 构造代码块可以理解为是在构造方法中被调用,优先于构造语句执行
         *  静态代码块fu
            静态代码块zi
            构造代码块fu
            构造方法fu
            构造代码块zi
            构造方法zi
         */
        
    }
}

class Fu {
    static {
        System.out.println("静态代码块fu");
    }
    {
        System.out.println("构造代码块fu");
    }

    public Fu() {
        System.out.println("构造方法fu");
    }

}

class Zi extends Fu {
    static {
        System.out.println("静态代码块zi");
    }
    {
        System.out.println("构造代码块zi");
    }

    public Zi() {
        System.out.println("构造方法zi");
    }
}

6 override 和 overload的区别，overload可以改变返回值类型吗？

　　overload可以改变返回值类型，只看参数列表

　　override：子类出现了和父类中方法声明一模一样的方法（参数列表相同，修饰符也相同），与返回值类型有关，返回值是一样的（或者是子父类的）

　　override：方法重载，本类中出现了方法名一样，参数列表的同的方法，与返回值类型无关。

7 final

　　final修饰类，类不能被继承

　　final修饰方法，方法不能被重写

　　final修饰变量，变量只能被赋值一次

8 多态时，变量与方法访问

　　1.成员变量访问时，编译看左边，运行看左边，因为是Person p = new Student()，p能看见的是对象中所保留的父类的那一部分。
　　2.静态方法访问时，编译看左边，运行看左边。静态方法调用时，相当于是类名点调用，所以调用到父类方法。

　　3.成员方法访问时，编译看左边，运行看右边，这叫做动态绑定。

package javademo2;

public class T1 {
    public static void main(String[] args) {
        Fa f = new Zi();
        System.out.println(f.num);//10  多态成员变量访问时:编译看左边,运行看左边
        
        Fa f2 = new Zi();
        f2.print();//zi  多态成员方法访问(动态绑定):编译看左边,运行看右边.左边没有print方法时,编译会通不过
        
        f2.method();//method in fa   静态方法访问,编译看左边,运行看左边
    }
}

class Fa{
    int num = 10;
    public void print(){
        System.out.println("fa");
    }
    public static void method(){
        System.out.println("method in fa");
    }
    
    
}

class Zi extends Fa{
    int num = 20;
    
    public void print(){
        System.out.println("zi");
    }
    
    public static void method(){
        System.out.println("method in zi");
    }
}

 9 abstract不能和哪些关键字共存

　　1.static，被static修饰的方法，可以直接用类名点调用，但是类名点调用被abstract修饰的抽象方法，没有任何意义。

　　2.private，被private修饰的方法，不能被子类继承，被abstract修饰的方法就是需要子类继承并重写，相冲突。

　　3.final，被final修饰的方法不能被重写，被abstract修饰的方法就是需要子类重写，相冲突。

10 内部类--成员内部类，静态内部类，局部内部类，匿名内部类

//成员内部类
public class T4 {
    public static void main(String[] args) {
        Outer.Inner i = new Outer().new Inner();
        i.func();
    }
}


class Outer{
    String name = "jack";
    class Inner{
        public void func() {
            System.out.println(name);
        }
    }
}

//静态内部类
public class T3 {
    public static void main(String[] args) {
        Outer.Inner i = new Outer.Inner();
        i.print();  
        Outer.Inner2.func();
    }
}

class Outer{
    static class Inner{
        public void print(){
            System.out.println("method1111");
        }
    }
    
    static class Inner2{
        static void func(){
            System.out.println("func");
        }
    }
}


//局部内部类访问局部变量
public class T5 {
    public static void main(String[] args) {
        new Outer().method();
    }
}


class Outer{
    public void method(){
        final int num = 20;
        class Inner{
            public void func(){
                System.out.println(num);
            }
        }
        
        Inner i = new Inner();
        i.func();
    }
}

//成员内部类私有
public class T2 {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
    
}


class Outer{
    private class Inner{
        public void print(){
            System.out.println("print1111");
        }
    }
    
    public void method(){
        Inner i  = new Inner();
        i.print();
    }
}

//内部类面试题
public class T4 {

    public static void main(String[] args) {
        Outer.Inner i = new Outer().new Inner();
        i.method();
    }

}

class Outer{
    int num = 30;
    class Inner{
        int num = 20;
        public void method(){
            int num = 10;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outer.this.num);
        }
    }
}

//匿名内部类面试题
public class T6 {
    public static void main(String[] args) {
        Outer.method().show(); //输出helloword
    }
}

interface Inter{
    void show();
}

class Outer{
    public static Inter method(){
        return new Inter(){
            public void show(){
                System.out.println("helloword");
            }
        };
    }
}