基础知识二

重载(Overload)和重写的区别.重载的方法能否根据返回类型进行区分.

重载:在同一个类中,方法名相同,参数列表不同(参数类型不同,参数个数不同或者两者都不同),就是重载,重载对返回类型没有特殊要求,也就是说重载的方法不能根据返回类型进行区分.

重载的规则：

1）、必须具有不同的参数列表；

2）、可以有不同的返回类型，只要参数列表不同就可以了；

3）、可以有不同的访问修饰符；

4）、可以抛出不同的异常；

       重写(Override):重写发生在子类和父类之间,重写要求子类重写的方法和父类被重写的方法具有相同的返回类型,不能比父类被重写方法声明更多的异常(里氏代换原则),必须要保证子类方法的权限大于或者等于父类方法的权限.

      父类方法被默认修饰时，只能在同一包中，被其子类被重写，如果不在同一包则不能重写。

      父类的方法被protoeted时，不仅在同一包中，被其子类被重写，还可以不同包的子类重写。

      父类的方法如果被private修饰,那么,任何包,任何子类都无法重写

override（重写）

　　 1、方法名、参数、返回值相同。

　　 2、子类方法不能缩小父类方法的访问权限。

　　 3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。

　　 4、存在于父类和子类之间。

　　 5、方法被定义为final不能被重写。

---

java中构造对象时构造器的调用顺序

      先初始化静态成员,然后调用父类构造器,再初始化非静态成员,最后调用自身构造器.

      当子类创建对象后，该子类对象本身可以使用this来指代，而该对象当中的父类对象空间可以使用super来指代。

---

如何将A编码的字符串转为B编码的字符串

①方法一

String s1="aaa";

String s2=new String(s1.getBytes("B编码"),"B编码");

 

//utf-8转gbk String clientStr = new String(str.getBytes("GBK"), "GBK");

//gbk转utf-8 String clientStr = new String(str.getBytes("UTF-8"), "UTF-8");

 

utf-8转GBK演示

①方法二 利用BASE64Encoder/BASE64Decoder实现互转

 

 

---

多态

①:最终多态体现为父类引用变量可以指向子类对象。(父类引用接收子类对象)

②:多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。

③:可以调用一切父类的方法，子类特有的方法将不能调用。

 

向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程

向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的！

多态本身就是一个向上转型的过程,所以多态的存在意义(优点)为：

配合继承与方法重写提高了代码的复用性与扩展性，如果没有方法重写，则多态同样没有意义。

 多态的弊端: 不能调用子类的特有方法

---

static

①:static是静态修饰符，一般修饰成员。被static修饰的成员属于类，不属于单个这个类的某个对象。

②:static修饰的成员被多个对象共享。

③:static修饰的成员属于类，但是会影响每一个对象。

④:被static修饰的成员又叫类成员，不叫对象的成员。

⑤:被static修饰的成员可以并且建议通过类名直接访问

静态代码块

   静态代码块是定义在成员位置，使用static修饰的代码块。

特点：

l 在一同一个类中,它优先于主方法执行、优先于构造代码块执行，当以任意形式第一次使用到该类时执行。

l 该类不管创建多少对象，静态代码块只执行一次。

l 可用于给静态变量赋值，用来给类进行初始化。

---

内部类

 

 什么是内部类

       将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

什么时候使用内部类

       在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

 

内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。

      内部类可以是静态static的，也可用public，default，protected和private修饰。（而外部顶级类即类名和文件名相同的只能使用public和default）。

内部类分为成员内部类与局部内部类。

       我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

 

1. 成员内部类

      成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。

成员内部类不能含有static的变量和方法。因为成员内部类需要先创建了外部类，才能创建它自己的

 

2. 局部内部类

      局部内部类，是指内部类定义在方法和作用域内

匿名内部类(属于局部内部类的一种)

      有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字。

定义的匿名内部类有两个含义：

  临时定义某一指定类型的子类

  定义后即刻创建刚刚定义的这个子类的对象

 

匿名内部类:

使用条件:前提是存在一个类或者一个接口

匿名内部类不能继承类或者实现接口,但是一个内部类可以作为接口,由另一个内部类实现

 

除了只能使用一次，其实还有其他用处（在看spring-boot源码时发现的）

当你想使用一个类的protected 方法时，但是又不和这个类在同一个包下，你是没办法调用的。

这时候匿名类就派上用场了，你可以声明一个匿名类继承该类，并定义一个方法，在这个方法内使用super调用你想调用的那个方法（其实你也可以写个类继承这个类，就能调用父类的protected方法了，但是匿名类更简洁，因为你只想调用这个方法而已）

 在使用匿名内部类的过程中，我们需要注意如下几点：

      1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

      2、匿名内部类中是不能定义构造函数的。

      3、匿名内部类中不能存在任何的静态成员变量和静态方法。

      4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

      5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

 

往OuterClass类的代码段中插入内部类声明, 哪一个是错误的:____。

public class OuterClass{
     private float f=1.0f;
     //插入代码到这里
}

A、class InnerClass{
public static float func(){return f;}
}

B、abstract class InnerClass{
public abstract float func(){}
}

C、static class InnerClass{
protected static float func(){return f;}
}

D、public class InnerClass{
 static float func(){return f;}
}

正确答案：ABCD

静态的内部类 才可以定义static方法，排除AD；

B抽象方法中不能有方法体；

C静态方法不能够引用非静态变量。

 

---

说一下你对堆内存和栈内存的理解

      在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的    作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。

P = null;

堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。

---

java 中的this关键字的几种用法(This指当前引用，一般在方法里使用 )

1.     当成员变量和局部变量重名时，在方法中使用this时，表示的是该方法所在类中的成员变量。（this是当前对象自己）

2．把自己当作参数传递时，也可以用this.(this作当前参数进行传递)

3．有时候，我们会用到一些内部类和匿名类，如事件处理。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。

4．    在构造函数中，通过this可以调用同一类中别的构造函数。如：

值得注意的是： 

　　1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。 

　　2：不能在构造函数以外的任何函数内调用构造函数。 

　　3：在一个构造函数内只能调用一个构造函数。

---

Final和abstract可以同时修饰一个类吗？

 

      Final修饰类代表该类不可被继承，abstract修饰一个类时表示该类是抽象类，不可创建对象，用于被子类继承。两者互相矛盾，所以不可以

 

---

short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗？

 

       第一个有错,因为 s1 是short类型,而 1 是 int类型,两个值相加会自动向上转型,变成int 类型,但使用 short类型接收就会报错,而第二虽然结果也是int类型,但自增运算可以自动强转类型,因此结果是short类型的,这时用short类型接收就没错.

 

---

关于json解析数据(json序列化javaBean对象为字符串时,依赖的是对象中的 get方法)

      在后台向页面提交数据时,首先提交的是一个json格式的字符串,但是在页面中声明用json解析数据,就会把这个字符串解析成一个json对象.

如何把一个java对象解析成json格式的字符串数据,首先,在javaBean中必须有get方法,例如 getName,

 

这时 Name就会全部转化成小写作为json格式数据的 键, 它的返回值就是 值,以此来拼接成 json格式的字符串数据

---

当导入多个框架的包时,包中会有重复的包,这时需要删除重复的包,删除低版本的.

---

hashcode和equals方法 

 

      equals()相等的两个对象，hashcode()一定相等，equals()不相等的两个对象，却并不能证明他们的hashcode()不相等。换句话说，equals()方法不相等的两个对象，hashCode()有可能相等。

为什么有hashcode()方法的存在?

      比如在一个person类的编写中,重写了equals方法,创建两个对象,然后比较两个对象是否相同,这时如果使用equals方法,看下图

 

      需要进行多个条件的判断,效率比较低下,但是如果重写了hashcode方法,这是就是对数值的判断(name是String类型,会调用String.class的hashcode方法,返回一个int值)

 

hashcode未重写hashcode方法时,值是对象的地址值转化的hash值,

      重写后,跟原来的地址没关系,和属性有关,如果是基本数据类型,不需要进一步的转化,

      但是如果是引用数据类型,需要进一步的转化,如果属性值一样,那么hashcode值就是相同的

      在比较两个对象是否相同时,有了hashcode的方法,就可以用hashcode方法先判断,如果hashcode值 不相同,那么这两个对象就不同 ,就不需要equals方法的判断,如果hashcode,这时再去进行equals方法的判断,可以提高执行效率

 

那么hashcode值相同,属性就相同吗

不 例如 30+20=50 40+10=50,所以这种说法错误

 

---

如何打印int数据二进制值

Integer.toBinaryString(10)

---

java中只存在值传递，只存在值传递！！！

https://www.cnblogs.com/coderising/p/5697986.html

java中方法参数传递方式是按值传递。

如果参数是基本类型，传递的是基本类型的字面量值的拷贝。

如果参数是引用类型，传递的是该参量所引用的对象在堆中地址值的拷贝。

 

 

---

抽象类(Abstract Class)和接口(interface)的异同

一切事物均有功能，即一切事物均有接口。

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。

接口中的方法默认使用public、abstract修饰

接口中的属性默认使用public、static、final修饰

 

抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类

抽象类一定是个父类，因为抽象类时不断抽取共性需求而来的。

相同点:

①:抽象类和接口都不能实例化,但可以定义抽象类和接口的引用

②:都能包含抽象方法

③:都位于继承的顶端,用于被其他类实现或继承;

不同点:

	抽象类(Abstract Class)	接口(interface)
构造器(构造方法)	抽象类可以有构造器(构造方法)	接口不能有构造器(构造方法)
默认的方法实现	它可以有默认的方法实现	接口完全是抽象的。它根本不存在方法的实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
访问修饰符	抽象方法可以有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法	抽象方法可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口,但是不能继承类
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
基本数据类型	不是必须用static修饰	基本数据类型默认为static 修饰,在子类中不能修改
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。

 

二者的选用:

l 优先选用接口,尽量少用抽象类;

l 需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

---

final的特点

①:final修饰类不可以被继承，但是可以继承其他类。

②:final修饰的方法不可以被覆盖,但父类中没有被final修饰方法，子类覆盖后可以加final。

③:final修饰的变量称为常量，这些变量只能赋值一次。

④:引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性值可以修改。

 

⑤:修饰成员变量，需要在创建对象前赋值，否则报错, 也可以成员变量不赋值,但是构造方法必须赋值