JAVA 常识

（1）Java语言具有哪些特点？

1. Java为纯面向对象的语言。它能够直接反应现实生活中的对象。
2. 具有平台无关性。java利用Java虚拟机运行字节码，无论是在Windows、Linux还是MacOS等其它平台对Java程序进行编译，编译后的程序可在其它平台运行。
3. Java为解释型语言，编译器把Java代码编译成平台无关的中间代码，然后在JVM上解释运行，具有很好的可移植性。
4. Java提供了很多内置类库。如对多线程支持，对网络通信支持，最重要的一点是提供了垃圾回收器。
5. Java具有较好的安全性和健壮性。Java提供了异常处理和垃圾回收机制，去除了C++中难以理解的指针特性。
6. Java语言提供了对Web应用开发的支持。

      java面向对象的特征

     封装：把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。但是可以提供一些可以被外界访问的方法来操作属性.同时保护了数据。代码可以重复使用 ，复用性。

     继承：子类继承父类。避免了类之间共同特征的重复描述，继承可以清晰表达每一项共同特征适应的概念范围。复用性

1. 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。
2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3. 子类可以用自己的方式实现父类的方法。（以后介绍）。

     多态   类之间的关系   继承 重写 父类引用指向子类对象  灵活性 可移植性

    

• 对象类型和引用类型之间具有继承（类）/实现（接口）的关系；
• 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
• 多态不能调用“只在子类存在但在父类不存在”的方法；
• 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法

（2）int char String 转换

    int x = 1;
        char xc = (char) (x + 97);
        char xcc = (char) (x + 65);
        System.out.println(xc + " " + xcc);//b B
        char p = 'c';
        int nump = p - 'a';
        System.out.println("c 对应数字:" + nump);//2
        int a = 1245;
        String as = String.valueOf(a);
        int numa = Integer.valueOf(as);
        System.out.println(as + " " + numa);//1245 1245

 （3）Java1.8新特性

https://blog.csdn.net/weixin_42210904/article/details/91987891

1.Lambda表达式；

2.函数式接口；

3.方法引用和构造器引用；

4.Stream API；

5.接口中的默认方法与静态方法；

最为核心的是Lambda表达式与Stream API.

1.Lambda表达式

写出更加简洁、灵活的代码。作为一种更加紧凑的代码风格，使java的语言表达能力得到了提升。

Lambda表达式在Java语言中引入了一个新的语法元素和操作符。这个操作符号为"->",该操符被称为Lambda操作符 或箭头操作符。它将Lambda分为两个部分：

左侧：指定了Lambda表达式的所有参数。

右侧：制指定了Lambda体，即Lambda表达式要执行的功能。

import java.util.*;

interface Runnable {
    public abstract void run();
}

public class Main {

    public static void main(String[] ages) {
        Runnable run1 = () -> System.out.println("wefwr");// ()可以没有参数
        run1.run();//wefwr
        PriorityQueue<Integer> que = new PriorityQueue<>((x, y) -> (y - x));
        for (int i = 3; i <= 5; i++)
            que.offer(i);
        while (!que.isEmpty()) {
            int tmp = que.poll();
            System.out.println(tmp);//5 4 3 
        }

    }

}

2.函数式接口

新增四个函数式接口

Supplier：生产者，有一个get方法
Consumer：消费者，有accept方法和andThen（）
Function：apply方法，传一个类型的值，返回另一个类型的值，也有andThen，compose 方法（应该是执行先后的问题，源码里一个before，一个after），还有identity方 法（返回本身？？）
Predicate：test方法，做判断用，返回boolean类型

有且只有一个抽象方法的接口

import java.util.*;

@FunctionalInterface
interface Add {
    public int addnum(int a, int b);
}

public class Main {

    public static void main(String[] ages) {
        Add add1 = (a, b) -> a + b;
        Add add2 = (a, b) -> a + b + 1;
        int num1 = add1.addnum(2, 4);
        System.out.println(num1);//6
        int num2 = add2.addnum(2, 4);
        System.out.println(num2);//7

    }

}

3.方法引用与构造器引用

4.Stream API

https://www.cnblogs.com/wuhenzhidu/p/10740091.html

Stream是Java8中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤映射数据等操作。使用Stream API对集合数据进行操作，就类似于使用SQL执行的数据库查询。也可以使用Stream API来并行执行操作。简而言之，Sream API提供了一种高效且易于使用的处理数据方式。

什么是Stream？

就是数据渠道，用于操作数据源（集合、数组）所产生的元素序列。

注意：

1.Stream 自己不会存储元素。
2.Stream 不会改变源对象。相反，他们会返回一个持有结果的新的Stream。

3.Stream 操作是延迟执行的。这意味着他们会等到需要的结果的时候才会执行

import java.util.*;

class Person {
    private String name;
    private int age;
    private String country;

    public Person(String name, int age, String country) {
        this.name = name;
        this.age = age;
        this.country = country;
    }

    public int getage() {
        return age;
    }

    public String toString() {
        return "name: " + name
                + "age: " + age + "country: " + country;
    }
}

public class Main {

    public static void main(String[] ages) {
        List<Person> personlist = new ArrayList();
        personlist.add(new Person("张三", 15, "China"));
        personlist.add(new Person("Tom", 25, "USA"));
        personlist.add(new Person("李四", 18, "China"));
    
        // 1）找到年龄大于18岁的人并输出；
        personlist.stream().filter(p -> p.getage() >= 18).forEach(System.out::println);

    }

}

name: Tomage: 25country: USA
name: 李四age: 18country: China

5 接口中的默认方法与静态方法

Java8 中允许接口中包含具有具体实现的方法，该方法称为“默认方法”，默认方法使用default关键字修饰。

例如：

若一个接口中定义了一个默认方法，而另外一个父类或接口中又定义了一个同名的方法时：

1.选择父类中的方法。如果一个父类提供了具体的实现，那么接口中具有相同名称和参数的默认方法会被忽略。

2.接口冲突。如果一个父接口提供一个默认方法，而另一个接口也提供了一个具有相同名称和参数列表的方法（不管方法是否是默认方法），那么必须覆盖该方法解决冲突。

（4） Java提供的多态机制？

多态：允许不同类的对象对同一消息作出响应。不同对象调用相同方法即使参数也相同，最终表现 行为是不一样的。

Java多态可以分为编译时多态和运行时多态。

编译时多态主要指方法的重载，即通过参数列表的不同来区分不同的方法。在编译期间就可以确定调用哪个方法。

import java.util.*;

public class Main {
    int add(int a, int b) {
        return a + b;
    }

    int add(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(String[] args) {
        Main ma = new Main();
        System.out.println(ma.add(1, 2));// 3
        System.out.println(ma.add(1, 2, 3));// 6
    }
}

运行时多态主要指继承父类和实现接口时，可使用父类引用指向子类对象。

在运行时确定对象的类型。对象的类型决定了要调用哪个版本的方法

作用：允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码

运行时多态的实现：主要依靠方法表，方法表中最先存放的是Object类的方法，接下来是该类的父类的 方法，最后是该类本身的方法。

如果子类改写了父类的方法，那么子类和父类的那些同名方法共享一个 方法表项，都被认作是父类的方法。因此可以实现运行时多态。

import java.util.*;

class Father {
    public void method() {
        System.out.println("father!!!");
    }
}

public class Main extends Father {
    public void method() {
        System.out.println("sonson!!!");
    }

    public static void main(String[] args) {
        Father fa = new Father();
        fa.method();//father!!!
        Main ma = new Main();
        ma.method();//sonson!!!
        Father fm = new Main();
        fm.method();//sonson!!!

    }
}

最后，对于多态做出几点总结

1、使用父类类型的引用指向子类的对象；
2、该引用只能调用父类中定义的方法和变量；

子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有
3、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；（动态连接、动态调用）
4、变量不能被重写（覆盖），”重写 “的概念只针对方法，如果在子类中无法” 重写“父类中的变量

 

import java.util.*;
 class Fa{
    String x  ="fafa";
    private  String y  ="sysyy";
    public void fn(){
        System.out.println("ffff");
    }
}
public class Main extends Fa {
     String x  ="sasasa";
    
    @Override
    public void fn(){
        System.out.println("sssss");
    }
    public static void main(String[] args) {
       
       Fa fa  =new Main();
       fa.fn();
       System.out.println(fa.x);
        System.out.println(fa.y);
      
    }
}

sssss
fafa

 error: y has private access in Fa
	    System.out.println(fa.y);

 

（6）序列化是什么？

序列化是一种将对象转换成字节序列的过程，用于解决在对对象流进行读写操作时所引发的问题。

序列化可以将对象的状态写在流里进行网络传输，或者保存到文件、数据库等系统里，并在需要的时候把该流读取出来重新构造成一个相同的对象。

（7）重载  覆盖（重写）

重载是同一类中方法之间的关系，重载是多个方法之间的关系。是水平关系。返回值，参数列表可能不同。根据调用时实参表与形参表来对应选择方法体。

覆盖是子类重写父类的方法，要求方法名和参数类型完全一样(参数不能是子类)，返回值和异常比父类小或者相同(即为父类的子类)，访问修饰符比父类大或者相同

调用方法体是根据对象的类型来决定的

（9）理解JAVA的面向对象

面向对象编程其实是一种程序设计的规范，指导你如何进行程序的设计代码编写。可以以现实世界中客观存在的事物也就是对象去设计程序

例如 水果 就是一个类，水果有大小颜色等属性和吃水果的方法 。某种水果就是一个对象。总之，面向对象的关注点是对象，面向对象的程序设计中，主要就是通过各个对象去完成相应的功能，

关注的就是各个对象之间的互相操作。先抽象出对象，然后用对象执行方法的方式解决问题

面向过程：C语言就是一门面向过程的编程语言。 面向过程关注的就是其中的过程，主要就是通过一个个的函数来完成特定的功能，组合起来来完成整体的功能。主要就是关注数据的流向，

就是数据在各个函数之间的传递。

纯粹的Java

说到面向对象，那咱一定要说Java了，Java是一门纯粹的面向对象编程语言，对了Java是基于C++的，但是它别C++更加面向对象，为啥？

主要是Java在设计上是汲取了C++的优点的，具体表现为继续使用C++面向对象技术的核心，另外在C++中的指针是很容易引起错误的，所以这点Java是舍弃的，只不过在Java中使用了引用来代替指针，

另外也舍弃了C++中的运算符重载和多继承的特性，使用了接口来代替等。

(10)Java和C++的区别：
1. Java源码会先经过一次编译，成为中间码，中间码再被解释器解释成机器码。对于Java而言，中间码就是字节码(.class)，而解释器在JVM中内置了。

 C++源码一次编译，直接在编译的过程中链接了，形成了机器码。
2.C++ 依赖于特定的平台。但是Java可以利用JVM跨平台。
 
3. Java是纯面向对象的语言，所有代码（包括函数、变量）都必须在类中定义。在面向对象编程设计中，其最小的程序设计单元就是类.而C++中还有面向过程的东西，比如是全局变量和全局函数。
5. C++中有指针，Java中没有，但是有引用。

那指针是干嘛的，是用来操作内存的.一般的话我们写好的代码刚开始是在我们电脑上的硬盘中当程序要运行的话，就需要把程序加载进内存中才能运行.C++中就是用指针来操作内存中的这些数据，指针就是一个连接物.那放在Java中没有指针了，就是使用引用来解决和这个问题了。
6. C++支持多继承，Java中类都是单继承的。但是继承都有传递性，同时Java中的接口是多继承，类对接口的实现也是多实现。
7. Java ⽀持⾃动垃圾回收，⽽ C++ 需要⼿动回收.虽然有自己的GC机制，但是也会出现OOM和内存泄漏的问题。C++中有析构函数，Java中Object的finalize方法。
8. C++操作符可以重载，但是Java中不可以。同时C++中支持强制自动转型，Java中不行，会出现ClassCastException（类型不匹配）

(11)Java程序的创建和运行

首先我们也知道一个命令Javap，这个是Java自带的反解析编译器，可以查看Java编译器生成的字节码。那我们说说Java的运行过程。

1.Java源文件被编译器编译成字节码文件。

2.JVM将字节码文件编译成相应的操作系统机器码。

3.机器码调用相应操作系统的本地方法库执行相应的方法。

也就是说我们的Java源文件，通过javac命令编译生成字节码 .class文件，之后 .class文件又被JVM中的解释器编译成机器码，运行在不同的操作系统上（windows,linux,unix,mac等）运行。每种操作系统的解释器都是不同的，但基于解释器实现的虚拟机是相同的，这也是Java能够跨平台的愿因了

(12)Java的平台无关性是怎么实现的？

Java编译过程示意图

Java虚拟机（JVM)
不同的平台下的硬件和操作系统肯定也不一样，而且光是不同的硬件和操作系统的指令就已经不大相同了。所以要想做到平台无关，最重要的是要做到可以根据相应的硬件和操作系统，生成对应的二进制文件。

这一任务，由Java虚拟机完成，不同的操作系统书上需要安装对应的Java虚拟机。

虽说Java语言是平台无关性的，但JVM的确是平台有关的，在此的平台无关性是相对的（对于开发者来说，算是平台无关）
Java能做到跨平台，Java虚拟机功不可没，因为Java虚拟机是Java文件及其编译文件与硬件和操作系统之间的桥梁。

Class文件
JVM不会直接执行Java文件，实际上，JVM不仅被Java语言所使用，还有如Scala、Jython等语言的编译过程也使用JVM。也就是说JVM运行的时候并不依赖于Java语言，能在JVM上运行的文件是Class文件。

各种运行在不同平台上的虚拟机都统一使用字节码（Byte Code）组成的Class文件进行交互，而Class文件是由javac处理Java文件后得到的。

Class文件可以在任何平台上被创建，也可以被任何平台上的JVM装载运行。它的格式有着严格的定义，所以Class文件是构成平台无关性的基石之一。

Java语言规范
Java编程语言也在用它自己的方式支持这Java平台无关性事业的发展：它的基础数据类型的值域和行为是由语言自己定义的，不像C语言的是由平台决定。举个栗子，Java语言中，int类型无论是在16位操作系统、32位操作系统和64位操作系统下，都是占4个字节。

小结
总结一下，Java通过规定Java语言中基本数据类型的取值范围和行为，统一Java文件编译成Class文件，并且最后由Java虚拟机将Class文件转换成对应平台的二进制文件，才实现了平台无关性

什么是反射

　　反射就是把Java类中的各个成分映射成一个个的Java对象。即在运行状态中，对于任意一个类，都能够知道这个类的所以属性和方法；对于任意一个对象，都能调用它的任意一个方法和属性。

这种动态获取信息及动态调用对象方法的功能叫Java的反射机制。