java基础知识复习一

java基础知识

1.& 与 &&的区别

• 逻辑与&，无论左边是真是假，右边都会执行
• 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
• 逻辑或|，无论左边真假，右边都要执行。
• 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行

break和continue的区别

• break 跳出当前循环
• continue 跳出本次循环,执行下一次循环

2.成员变量和局部变量的区别

1.类中的位置不同

• 成员变量在类中方法外,局部变量在类中方法中

2.内存中的位置不同

• 成员变量在堆内存中,局部变量在栈内存中

3.生命周期不同

1. 成员变量随着对象的创建而创建，随着对象的消失而消失
2. 局部变量随着方法的创建而创建，随着方法的消失而消失

4.默认值不同

• 成员变量有默认的初始值
• 局部变量,没有默认初始值,必须定义之后再赋值才能 用

3.java的三大特性

封装,继承,多态

1.封装

• 封装原则:使用private关键字,将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类所提供的方法实现对隐藏信息的操作和访问

2.继承:

• 子类继承父类,通过extends关键字,当子类继承父类之后可以具有父类的非私有的属性和方法,还可以在子类中重新定义新的属性和方法,(记忆提示:师傅和徒弟)

2.1继承的好处和弊端

• 1.继承的好处:

• 1.提高了代码的复用性(多个类中相同成员的方法可以放在同一个类中)

• 2.提高了代码的维护性(如果代码需要修改,只需要修改一处就好)

• 2.继承的弊端:

• 让类与类之间产生了关系,耦合性增强,父类发生改变,子类也必须得跟着改变

3.使用场景:
当类与类之间的关系是is… a的关系的时候,使用继承比较好,
比如老师和学生是人类的一种,父类就是人类,而老师和学生就是子类.

• 成员访问特点:就近原则
• 子类局部范围----->子类的成员范围---->父类成员范围—>如果都没有就会报错,(不考虑父类的父类,如果有父类的父类继续向上查找)
• 成员方法的访问原则:就近原则
  • 子类成员—>父类成员… 如果都没有就报错

2.2this和super关键字的区别
1.this关键字(通过this关键字解决了局部变量和隐藏的成员变量之间的调用问题)

1. 代表本类对象的引用,哪一个对象调用我,我代表的就是那个对象
2. this.成员变量,访问的是本类当中的成员变量
3. this(…)访问的是本类当中的构造方法 this.成员方法,访问的是父类中的成员方法

2.super关键字

1. 代表父类对象的引用

2. super.成员变量,访问的是父类的成员变量

3. super(…)访问的是本类当中的构造方法 super.成员方法,访问的是父类中的成员方法

2.3 继承中构造方法的访问特点

1. 子类中所有的构造方法默认都会访问父类中的无参构造方法
2. 子类会继承父类中的数据,还有可能会使用父类中的数据,所以在子类初始化之前要先进行父类的初始化
3. 每一个子类构造方法的第一条语句默认为super()

如果父类中没有无参构造方法
1.使用super关键字,显示的去调用父类中的带参构造方法
2.在父类当中自己提供一个无参构造方法

2.4继承注意事项

java中类与类之间只支持单继承,不支持多继承,但是支持多层继承 (多继承可能会造成方法调用的不确定性,如:A继承了b,c ,bc中都有一个相同的方法,在进行重写的时候,子类就不知道重写的是哪一个父类中的方法了)

2.5代码块的访问顺序

• 1.测试类的静态代码块
• 2.父类静态代码块
• 3.子类静态代码块
• 4.父类构造代码块
• 5.父类构造方法
• 6.子类构造代码块
• 7.子类构造方法

3.多态:

3.1.概念:多态就是同一个对象在不同的时刻,所表现出来的不同形态,(猫既是猫猫又是动物)
3.2多态的前提条件:

• 要有继承和实现关系
• 要有方法的重写,父类引用指向子类对象

3.3多态成员的访问特点:

• 成员变量: 编译看父类,运行看父类
• 成员方法:编译看父类运行看子类(因为子类重写了父类中的方法)
• 静态方法: 编译看父类,运行看父类

3.4注意:

• 1.对于多态的转型自始至终都是子类对象在做类型的变化
• 2.向下转型是为了使用子类的特有方法
• 3.向上转型,是将子类隐藏就不能访问子类的特有方法

向下转型的时候,最多只能向下转换成子类本身,不能转换成其他类型,即使是转换成其子类也不行
instanceof:用于判断对象的具体类型,只能用于引用类型数据的判断 对象初始化过程:

默认初始化---->显示初始化---->构造初始化---->set初始化

4.抽象类

一个没有方法体的方法,应该定义为抽象方法,如果类中有抽象方法,该类必须为抽象类,使用abstract关键字修饰
1.特点:

• 1.抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
• 2.抽象类不能进行实例化(抽行类不能创建对象)

可以通过继承的方法,子类继承父类之后重写父类中的所有抽象方法,通过子类对象进行实例化

2.抽象类和接口的区别:

1.成员区别:
抽象类: 被abstract关键字修饰
       类中有变量, 常量；有构造方法；有抽象方法,也有非抽象方法
接口:
      只有常量,抽象方法
2.关系区别
	1.类与类之间是继承关系,只能单继承,可以多层继承
	2.类与接口之间是实现的关系,可以多实现,还可以在继承一个类的时候,实现多个接口
	3.接口与接口之间是继承的关系,可以单继承也可以多继承
3.设计理念
	1.抽象类      是对类的抽象,属性和行为的抽象
	2.接口         是对行为的抽象

3.抽象方法是否可以同时是静态的,是否可同时是本地方法,是否课被synchronized
不能

• 抽象方法需要子类被重写,但是静态的方法无法被重写
• 本地方法是由本地代码实现的方法,抽象方法是没有实现的
• synchronized和方法的实现细节有关,但是抽象方法中不涉及实现的细节

4.final关键字

1.可以修饰成员方法,成员变量,局部变量,类

• final修饰类,说明该类是最终类,不能被继承
• final修饰方法,该方法不能被重写
• final修饰变量,该变量是一个常量,不能对它进行再次赋值
• final修饰局部变量
  • 基本数据类型,变量的值不能被改变
  • 引用数据类型,变量的地址值不能发生改变,但是地址值是可以改变的

2.final ,finally ,finalize之间的区别

• final修饰符:被final修饰的类不能被继承
• finally: 在异常处理的时候提供的finally块,不管有没有抛出异常finally 块中的内容都会被执行,除非JVM退出
• finalize: 这个方法来自java.lang.Object包,用于回收资源

5.static关键字

1.特点: 被static修饰的方法无法被重写

• 1.static是一个修饰符,用于此时成员变量和成员方法
• 2.static修饰的成员变量被所有的对象所共享
• 3.static优先于对象存在,它随着类的加载而加载
• 4.被static修饰的成员,可以直接通过类名调用

2.成员变量和静态变量的区别
1.生命周期不同

• 成员变量随着对象的创建而存在,随着对象的被回收而释放
• 静态变量随着类的加载而存在,随着类的消失而消失 (弊端:生命周期太长)

2.调用方式不同

• 成员变量只能被对象调用

• 静态变量可以被对象调用,还可以被类名调用(建议直接用类名调用)

3.别名不同

• 静态变量别名是类变量
• 成员变量的别名是实例变量

4.存储位置不同

• 成员变量数据存储在堆内存的对象中,所以也叫特有数据
• 静态变量存储在方法区(的静态区)中 ,所以也叫对象的共享数据区

注意:

静态成员方法只能访问静态成员,
非静态既可以访问静态又可以访问非静态
静态方法中不可以使用this和super关键字

6.方法重载和方法重写的区别

重载:(与返回值类型无关)

• 在同一个类中,方法名相同参数列表不同(参数的类型不同或者数量不同)

重写:

• 1.在不同的类中,有继承关系
• 2.方法名相同,参数列表,返回值类型也必须一样
• 3.子类的访问修饰符的权限必须要大于等于父类
  重写的注意事项:

1.父类中的私有方法不能被重写
2.子类方法的权限必须大于等于父类
3.子类抛出的异常要小于父类

为什么函数不能通过返回值类型来区分重载**

• 因为在调用的时候不能指定类型信息,编译器不知道你要调用哪一个函数

如: float max(int a,int b)
    int max(int a, int b)
   当调用max(1,2)的时候,仅从返回值上是没有办法辨认使用哪一个方法的 

7.参数传递和内部类

1.参数传递
类名作为形参和返回值

• 方法中的形参或者返回值是类名,其实需要的是该类的对象
  实际传递的是该对象的地址值

抽象类作为形参和返回值

• 方法的形参或者返回值是抽象类名,其实需要的是该抽象类的子类对象

接口名作为形参和返回值

• 方法的形参或者返回值是接口名,其实需要的是该接口的实现类对象

2.内部类
1.内部类中的访问特点

• 内部类可以直接访问外部类中的成员,包括私有的成员
• 外部类要访问内部类中的成员,必须创建对象

2.匿名内部类

• new 类名/接口名(){ //重写方法}

前提: 存在一个类(具体类或者抽象类)或者接口

大多数时候在方法内部 定义,也可以在成员变量的位置定义

匿名内部类本质

• 抽象类—>子类的匿名对象
• 接口-------> 实现类的匿名对象

匿名内部类可以通过多态的形式接受
匿名内部类直接调用方法

public class Outer {
    public void method(){
        //是一个继承了该类或者实现了该接口的子类匿名对象,要调用方法必须使用对象.方法
        /* new Inter(){//匿名内部类
            @Override
            public void show() {//重写了接口或者类中的方法
                System.out.println("匿名内部类");
            }
        }.show();*/
//        如果想要多次使用该内部类，要用多态的方法接收该内部类对象
        Inter in = new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        in.show();//对象调方法
    }
}

什么时候使用匿名内部类:

1.当只需要调用一次的时候
2.接口或者抽象方法中需要重写的方法只有一个的时候

8.== 和equals 的区别

• 1.== 是一个操作符.equals是方法
• 2.基本数据类型相比较:
  == 比较的是值是否相等
• 3.引用数据类型相比较:
  ==和equals都是比较地址值是否相等
  equals方法被重写之后,比较的是对象的内容是否相同(区分大小写)