1.float f=3.4;是否正确?

答案：不正确。
原因：精度不准确,应该用强制类型转换，如下所示：float f=(float)3.4 或float f = 3.4f

在java里面，没小数点的默认是int,有小数点的默认是 double;

编译器可以自动向上转型，如int 转成 long 系统自动转换没有问题，因为后者精度更高
double 转成 float 就不能自动做了，所以后面的加上个 f;

2.short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗

Java的基本数据类型转换规则，大的数据类型转换为小的数据类型需要强制转换，反之可以自动转换。

赋值表达式等号两侧的转换的规则是右侧的向左侧的看齐，即右侧表达式要转换到和左边的类型一样。

第一题：short s1 = 1; s1 = s1 + 1;

错！ s1 + 1，s1是short类型，1是int型，s1会自动转换为int型的1，与1相加后，得到int型的2，要向左侧的short类型的s1看齐，即需要通过强制类型转换。正确写法：s1 = (short) (s1 + 1);

第二题：short s1 = 1; s1 += 1;

正确！ 执行s1+=1;其实执行的是s1 = (short) (s1 + 1); 其中会有一个强制转换的过程。

3.&和&&的区别

相同点：运算符，表示逻辑与（and）。

不同点：

（1）&&具有短路的功能，只要左端条件式为假直接不成立，不会去判断右端条件式。而&不具备短路功能。

（2）当&运算符两边的表达式的结果都为true时，整个运算结果才为true。而&&运算符第一个表达式为false时，则结果为false，不再计算第二个表达式。

（3）&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作，我们通常使用0x0f来与一个整数进行&运算，来获取该整数的最低4个bit位。

4.this关键字的用法

构造方法中的this关键字

构造方法是一个类的对象在通过new关键字创建时自动调用的，在程序中不能向调用其他方法一样通过方法名（也就是类名）来调用。但如果一个类有多个构造方法，可以在一个构造方法中通过this(paras…)来调用其他的构造方法。
使用this来调用其他构造方法有如下几个约束。

  1. 只能在构造方法中通过this来调用其他构造方法，普通方法中不能使用。
  2. 不能通过this递归调用构造方法，即不能在一个构造方法中通过this直接或间接调用该构造方法本身。
  3. 通过this调用其他构造方法必须放在构造方法的第一行中执行。由于super调用父类的构造函数也必须放在构造方法的第一行中执行，因此，通过this和super调用构造方法不能同时出现一个构造方法中。也不能在一个构造方法中多次调用不同的构造方法。
    在构造方法中也可以使用this关键字来访问本类中的成员变量和成员函数。其用法和非构造方法中的this关键字相同。

非构造方法中的this关键字

在Java中可以通过通过this关键字来调用类中的成员变量和方法。其用法是。

  1. this.xxx; 访问类中的成员变量xxx
  2. this.yyy(paras…); 访问类中的成员方法yyy
  3. this; 当前类对象的引用
    this关键字访问类的成员变量和成员函数时不受访问权限的控制，可以访问本类中所有的成员变量和方法，包括private的成员变量和方法。也可以通过this访问本类的static成员，不过由于static成员可以通过类名直接访问，如果通过this来访问会有“The static field ××× should be accessed in a static way”的警告信息。不能在类的static成员或static块中使用this。

继承关系下的this关键字

在继承关系下，父类中的this关键字并不总是表示父类中的变量和方法。this关键字的四种用法如前文所述，列举如下。

  1. this(paras…); 访问其他的构造方法
  2. this.xxx; 访问类中的成员变量xxx
  3. this.yyy(paras…); 访问类中的成员方法yyy
  4. this; 当前类对象的引用
    对第一种，无论子类是否有相同参数的构造方法，this(paras…);访问的始终是父类中的构造方法。
    对第二种，无论子类是否有覆盖了该成员变量，this.xxx;访问的始终是父类中的成员变量。
    对第三种，如果子类重写了该成员方法，则this.yyy(paras…);访问的是子类的成员方法，如果子类没有重写该成员方法，则this.yyy(paras…);访问的是父类的成员方法。
    对第四种，this始终代表的是子类的对象。

5.super关键字的用法

1.在子类的成员方法中，访问父类的成员变量。

class Fu{
    int num = 10;
}
class Zi extends Fu{
    int num = 20;
    public void methodZi(){
        System.out.println(num);//10
        System.out.println(super.num);//20 父类中的num
    }
}

2.在子类的成员方法中，访问父类的成员方法。

class Fu{
    public void method(){
         System.out.println("父类方法");
}
class Zi exteds Fu(){
    public void method(){
        super.method();//访问父类的method
         System.out.println("子类方法");
}

3.在子类的构造方法中，访问父类的构造方法。

class Fu{
    
}
class Zi exteds Fu(){
    public zi(){
        super();//访问父类的构造方法
    }
    
}

6.普通类和抽象类有哪些区别？

1.抽象类不能被实例化。

2.抽象类可以有构造函数，被继承时子类必须继承父类一个构造方法，抽象方法不能被声明为静态。

3.抽象方法只需声明，而无需实现，抽象类中可以允许普通方法有主体

4.含有抽象方法的类必须申明为抽象类

5.抽象的子类必须实现抽象类中所有抽象方法，否则这个子类也是抽象类。

7.抽象类能使用 final 修饰吗？

不能，抽象类是被用于继承的，final修饰代表不可修改、不可继承的。

8.静态变量和实例变量区别

在Java中，静态变量和实例变量可以统称为成员变量。静态变量也叫做类变量，独立于方法之外的变量，有static修饰。实例变量同样独立也是独立于方法之外 的变量，但没有static修饰。

实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。

静态变量不属于某个实例对象，而是属于整个类。只要程序加载了类的字节码，不用创建任何实例对象，静态变量就回被分配空间，静态变量就可以被使用了。结合上述给出的例子，无论创建多少个实例对象，永远都只分配一个staticInt 变量，并且每创建一个实例对象,staticInt就会加一。

总之，实例变量必须创建对象后，才可以通过这个对象来使用；静态变量则可以直接使用类名来引用（如果实例对象存在，也可以通过实例对象来引用）。

9.内部类相关，看程序说出运行结果

public class Outer {
    private int age = 12;

    class Inner {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Outer.this.age);
        }
    }

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

}

运行结果：

  1. 局部变量：14
  2. 内部类变量：13
  3. 外部类变量：12

在Java中内部类主要分为成员内部类(非静态内部类、静态内部类)、匿名内部类、局部内部类。

成员内部类(可以使用private、default、protected、public任意进行修饰。 类文件：外部类$内部类.class)

成员变量访问要点：

1. 内部类里方法的局部变量：变量名。

2. 内部类属性：this.变量名。

3. 外部类属性：外部类名.this.变量名。

以上内容是学习总结收集后的结果。