JAVA基础(持续更新。。。。。)

1.在子类构造器中使用super()显示调用父类的构造方法，super()必须写在子类构造方法的第一行，否则编译不通过；
2.在同一个.java文件中，在类中再去声明一个类，这个类的私有属性是可以在外面类的main函数中通过"对象.属性"可以直接调用，而不用再去写get函数，(可能是因为类中类的私有属性还属于外面类的属性，所以在其main函数中可以直接调用).
3.this()函数和super()函数不能出现在同一个构造函数中，因为super()必须在构造函数的第一行，而this()会调用该类的构造函数,无论怎么调整this(),super()的顺序，两个super()不可能都在第一行的.
从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
4.
①抽象类中可以有非抽象的函数，但是如果一个类中有抽象函数，其必须声明为抽象类。
②抽象类不能被实例化，实例化需要其子类来实现。
5.
public:对所有类或者对象都是可见的
proteced:范围缩小，对该类，该类所在包的其他类，该类的子类(无论在不在包中),可见。
default:范围再次缩小,对该类以及该类所在包的其他类可见。
private:范围再再次缩小，仅对该类可见。

private和protected一般不用来修饰外部类，而public、abstract或final可以用来修饰外部类（如果用private和protected修饰外部类，会使得该类变得访问性受限）。

若把一个类中的构造器(构造函数)指定为private，则不能访问该类，若要创建该类的对象，则需要再该类的static成员内部创建，如单例模式。

6.类中的静态代码块会在该类的对象创建时首先执行，比构造函数还要先执行，
即顺序为 static代码块—>构造函数
下面说一下加载一个类的时候，加载的顺序:
父类的静态域---->子类的静态域---->父类的成员变量---->父类的构造函数---->子类的成员变量
---->子类的构造函数。(父子父父子子)
7.函数参数为String类型，在函数体中改变形参的值，在外面是不改变的,
如果想要通过函数来改变外面字符串的值，需要用到StringBuilder，通过delete先把原先的值删除，然后再追加自己想要改编成为的值，即可完成修改。
(下面代码的执行结果为）

??
append

public static void changestr(StringBuilder string){
        string.delete(0,string.length());
        string.append("append");
    }

public static void main(String[] args) {
        StringBuilder str=new StringBuilder("??");
        System.out.println(str);
        changestr(str);
        System.out.println(str);
    }

8.Animal animal=new dog();其中dog为Animal的继承类，但是这样声明一个对象的话，
animal只可以调用类Animal中的函数，所以说向上转型会丢失具体类的信息。
9.当父类没有不带参数的构造方法时，子类需要使用super来显示调用父类的构造方法，super指的是对父类的引用
10.匿名内部类，刚才刚刚弄明白了匿名内部类是干什么用的，匿名内部类其实就是为了重写一个类的函数，并且调用这个重写的函数，继承可以实现这个需求，但是继承还需要创建一个类来继承，会很麻烦，这时候匿名内部类就出现了，他只需要new 类名 (){func()}.func（），在大括号内写上你想要改的函数，或者自己新添加函数也可以，最后通过“ .”来调用这个刚改的函数，这样的话，省去了创建子类的步骤，也就省去了起名字的烦恼，(不用给子类起名自然也不用给子类的对象起名),但是缺点也很明显，一次只能调用一个函数，如果想修改并调用多个函数，还是老老实实的写一个子类来继承父类吧。(大括号里可以写多个函数，但是只能调用一个),代码如下(Animal是一个类)，其中的父类也可以是一个接口，通过匿名内部类直接实现接口的方法并且调用

new Animal(){
            public void run(){
                System.out.println("匿名内部类run");
            }
            public void runnnnn(){
                System.out.println("runnnnnnnn");
            }
        }.run();

11.Father father=new Son();
现在Father中有两个函数，一个hit(),一个say()，say()被Son重写了，hit()没有，当调用say()时，调用的是Son重写后的say()，而调用hit()时则为父类的hit()(其实还是子类的hit()因为没有重写所以和父类的hit()是一样的)。
12.基本数据类型与包装类
所有的包装类（8个）都位于java.lang包下，分别是Byte，Short，Integer，Long，Float，Double，Character，Boolean
基本数据类型：byte：8位；short：16位；int：32位；long：64位；float：32位；double：64位；char：16位；boolean：8位。
一个字节的有:byte,boolean
两个字节的有:short,char
四个字节的有:int,float
八个字节的有:double,long
13“.== 与equals方法的区别
1.基本数据类型的比较：只能用==；
2.引用数据类型的比较：==是比较栈内存中存放的对象在堆内存地址，equals是比较对象的内容是否相同；

		String string="java";
        String string1="java";
        System.out.println(string==string1);
        System.out.println(string.equals(string1));

结果为两个true，因为String缓冲池中有"java"对象，所以两个指向同一个地址。
14.try catch finally
· 1.finally里面的代码一定会执行的；
· 2.当try和catch中有return时，先执行return中的运算结果但是先不返回，然后保存下来计算结果，接着执行finally，最后再返回return的值。
· 3.finally中最好不要有return，否则，直接返回，而先前的return中计算后保存的值得不到返回。
总之记住第一条就可以了，finally一定会执行，如果在finally中就return掉就得不到tryreturn的值，
反之，执行完finally再去return try中的值。
15.

List<Integer> list = new LinkedList<>();
        list.add(1);
        list.add(2);
        for (Integer integer: list) {
            System.out.println(integer);
        }
        for (Integer integer: list) {
            integer=5;
            System.out.println(integer);
        }
        for (Integer integer: list) {
            System.out.println(integer);
        }

最后的执行结果为1 2 ,5 5,1 2，说明在foreach中不能改变集合中的值。如果想改变的话就要用普通for循环调用list.set(i,5)来把下标为i的改为5。
16.
①环境变量中PATH是为了查找到可执行文件的路径(比如java.exe)，指定路径后，在任何地方打开cmd输入java都可以直接执行，如果不配置路径的话，必须要到可执行文件的路径下执行。
②环境变量CLASSPATH中，配置的是指定类的加载路径(放的tool.jar;dt.jar包等)
17.Java实现可移植性的原理
java程序转换为字节码，字节码再在JVM上运行，不同操作系统的JVM是不同的，但是对字节码的接口是相同的，所以JAVA可移植性高，可以跨平台运行。
18.
①普通与 & 和 普通或 | 两边的条件都需要执行并判断
②逻辑与 && 只要左边的错了右边的就不执行
    逻辑或 || 只要左边的对了右边的就不执行。
19.
①static函数只能继承，不能被重写(Override)
②static函数中不能使用this。因为this指向当前对象，而static是最先加载的，这个时候还没有对象，使用this会报错
③static只能访问static的，因为static是最先加载的，非static未被加载就访问就会出错。
20
什么是JavaBean？
JavaBean其实就是一个普通的Java类，它还具有一下几个要求
①所有属性必须为私有的
②每个属性都有getter、setter方法
③都有无参构造函数
④都实现序列化接口
21
Java单例模式，单例模式，顾名思义就是这个类只能有一个实例对象
①饿汉模式，它要求(对象在类加载的时候就创建了，线程安全)
1)有一个private的static的该类对象的属性，并且需要初始化好。
2)需要一个private的构造函数。
3)需要一个public的static的get函数来获取到1)中的属性。

package com.javaTest.singleExample;

public class HungryMan {

    private static HungryMan hungryMan=new HungryMan();
    private HungryMan(){

    }
    public static HungryMan getHungryMan() {
        return hungryMan;
    }
}

②懒汉模式（线程不安全的）

package com.javaTest.singleExample;

public class LazyMan {
    private static LazyMan lazyMan=null;
    private LazyMan(){

    }
    public static LazyMan getInstance(){
        if(lazyMan==null){
            lazyMan=new LazyMan();
        }
        return lazyMan;
    }
}

饿汉懒汉模式的区别在于，饿汉是在编译时候就已经创建好对象了，而懒汉是在使用的时候如果没有这个对象再去创建，有这个对象就直接返回。
**单例模式的优点：**节省内存，只有一个实例对象在内存中，应用场景如网页在线人数计数器
单例模式的缺点不利于扩展，扩展要更改代码

22
外部类只能够用public和default（不写）修饰，原因如下
①private不用说了，如果一个外部类声明为private，别的类就无法访问到了，这个类也就没有意义了
②protected，它是包内可见和子类可见，如果一个包外的类想要访问，必须是他的子类，而要想成为它的子类，那个类就必须能够访问到它，所以互相矛盾，就不能用protected
23
接口的中方法必须用public或者默认不写
24
工厂模式
①创建一个工厂接口
②创建多个类实现这个接口(其中的函数)
③创建一个工厂类，通过不同的值来创建不同的②中的类对象
优点:创建对象繁琐以及多的时候，工厂模式可以减少代码量，以及减少错误，用的时候也不用管创建对象的细节
缺点:如果需要添加新的类，则就需要改变工厂类了。当系统中的具体产品类不断增多时候，可能会出现要求工厂类根据不同条件创建不同实例的需求，不利于系统的维护
25.基本数据类型和引用数据类型
①基本数据类型包括byte、boolean、char、short、int、float、long、double
基本数据类型的数据存放在栈中，在函数参数传递时只传值，不会改变实参的数据值
②应用数据类型包括类、接口、数组，他们把实际值的地址存放在栈中，实际的值存放在堆中，
在函数参数传递时，会改变实际参数的值，但是要注意String、Integer等包装类型的对象虽然是引用类型，但是传递参数时不会改变实际参数的值，因为他们没有get，set方法，(数组可改变实际参数的值)
26.Java中的集合分为两大类：
①Collection（value）：包含list和Set，其中list是有序，可重复的；set是无序，不可重复的。
②Map（key-value）包含HashMap、HashTable、CurrentHashNap
27.线程的实现方式
①继承Thread类②实现Runnable接口③实现Callable接口
28.Java中设计模式和常用的设计模式
共有23种设计模式，常用的设计模式有:
①单例模式②工厂模式③代理模式
29.Mysql种默认最大连接数为
Mysql种默认最大连接数为100
30.JDBC连接五个操作步骤
①加载驱动
②获取数据库连接
③创建一个statement对象(静态statement:Statement stmt:动态statement:PreparedStatement pstmt;)
④执行sql语句
⑤关闭JDBC对象
31.数据库优化方法
①创建索引
②分表:水平分表或者垂直分表
③读写分离
④使用reids缓存