闲聊java

已于 2023-04-04 16:34:18 修改
阅读量224 收藏
点赞数
文章标签： java servlet 开发语言
于 2021-03-12 11:37:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37950196/article/details/114692080
版权

一、2021-03-02

第一章 、java语言简介

​ java是一门高级编程语言，诞生于1994年美国的贝尔实验室，由高斯林以及他的团队编写。

​ java的平台有JavaSE(java标准版)、JavaME(移动端)、JavaEE(企业版)。

​ 特性有：安全性、健壮性、移植性(跨平台)。

第二章、搭建java开发环境

JDK

​ 1、下载JDK1.8：JDK是java的开发工具包，包含javac编译命令、javadoc文档命令等

​ 2、安装 傻瓜式下一步。

​ 3、配置环境变量。

maven

​ setting.xml文件

<?xml version="1.0" encoding="utf-8"?>  
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">  
     
    <localRepository>/usr/local/repository</localRepository>    
    <mirrors>  
        <!-- mirror | Specifies a repository mirror site to use instead of a given   
            repository. The repository that | this mirror serves has an ID that matches   
            the mirrorOf element of this mirror. IDs are used | for inheritance and direct   
            lookup purposes, and must be unique across the set of mirrors. |   
        
	<mirror>
		<id>alimaven</id>
		<mirrorOf>central</mirrorOf>
		<name>aliyun maven</name>
		<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
	</mirror>-->
	<mirror>
		<id>alimaven</id>
		<name>aliyun maven</name>
		<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
		<mirrorOf>central</mirrorOf>
	</mirror> 
    </mirrors> 
    <profiles>  
	<profile>
	    <id>spring plugins</id>
	    <activation>
		<jdk>spring plugins</jdk>
	    </activation>
	    <pluginRepositories>
		<pluginRepository>
		    <id>spring plugins</id>
		    <name>Spring plugins</name>
		    <url>https://maven.aliyun.com/repository/spring-plugin</url>
		    <layout>default</layout>
		    <snapshots>
		        <enabled>true</enabled>
		        <updatePolicy>daily</updatePolicy>
		    </snapshots>
		</pluginRepository>
	    </pluginRepositories>
	</profile>
    </profiles>    
    <!--   
    <activeProfiles>  
        <activeProfile>nexus</activeProfile>  
    </activeProfiles> -->
     
</settings>

IDEA

第三章、初识java开发

JavaEE

​ java企业级开发，涉及HTML5、CSS3、javascript、servlet、xml、jsp…tomcat

​ MVC模式：是一种设计思想，不是框架。主要是将各个模块分离，各司其职，为前后端分离奠定基础。

​ model1模式：model、view、controller全部在页面中处理。

​ model2模式：controller分离。

​

​ model：模型层。POJO、dao。

​ view：视图层。vue、jsp、html、css3…

​ controller:控制层。SpringMVC、Strust2，servlet…

Spring

​ 提供企业级开发的一站式解决方案，主要目的是简化开发，提高开发效率。

​ IOC（控制反转） 容器：提供了javaBean的装载容器。

​ AOP面向切面编程。

​

package test;

import org.springframework.beans.factory.annotation.Autowired;

import java.util.Date;

public class Test2 {
    
    @Autowired
    private Date date;

    public static void main(String[] args) {
        // IOC是一种思想。将new对象改为容器注入。
        Date date = new Date();
    }
}

SpringBoot

​ 实际上还是Spring，为了摆脱繁琐的配置文件而编写的框架，只需要少量的配置便可生成一个企业级的项目。

​ application.yml

​ application.properties

​ pom.xml

SpringMVC

控制层

MyBatis-Plus

​ 持久层框架。

第四章、java基本概念

JDK

​ java开发工具包，包含编译工具javac，运行工具java和java API库等

JRE

​ java运行环境，包含java运行环境所需的包。

JVM

​ java虚拟机。

第五章、java数据类型划分

四种基本数据类型

​ byte

​ short

​ int

​ long

布尔型 boolean

字符型 char

浮点型 float double

第六章、java运算符

+  -  *   /   &&  ||  !  &  >  <

第七章、java程序逻辑控制

for

which

if

第八章、方法的定义及使用

public        static void main(String[] args) {}
全限定修饰词    保留字  返回值  方法名   参数        方法体
publicprotectprivate
不同包是否否否
同包是是否否
不同类是是是否
同类是是是是

二、2021-03-03

第1章 、类与对象

类

概述：是一类事物的总称，“万物皆对象”的抽象。可以理解为模板，按照这个模板制造具体的物体。

生成类的方式：

​ new User user = new User();

​ 反射 : 利用全限定性类名创建对象。Spring IOC容器就是利用反射创建对象。

​ 克隆 : 实现Cloneable接口，表示这个类可以被克隆。浅克隆：同一对象的指针指向多个名字。深克隆：重新制造对象。两个对象之间不存在关联。

​ 序列化: 跨网络间传递的信息。用于缓存。

关系：

​ 继承 子类 父类

1.封装 ：将物体的属性（成员变量）和行为（成员方法）进行封装，只关注物体有哪些属性和哪些行为，并不关注行为的具体过程。

2.继承 :子类扩展父类的属性和行为的过程。private不能继承。体现java的扩展性。java属于单继承。

3.多态：不同实体对同一事物做出不同表现的行为。

对象

是类的具体个体。对象在堆内存分配运行所需的空间。

引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。

第2章 深入分析类和对象

栈内存里面存放基本类型的变量和对象的引用变量

堆内存里面存放new创建的对象和数组。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6ULFS3Jg-1615520177488)(/home/wf/Documents/java栈和堆.png)]

匿名对象

没有栈指向的堆内存空间就是匿名对象，而且只能使用一次，然后就被回收；

匿名内部类：不指定类名的内部类。一定程度上，后来JDK8的被lamda表达式代替。

第3章、this关键字

this关键字表示当前对象，或者当前对象的一个实例，通过this可以调用本对象的所有方法和属性。

1、当成员变量和局部变量重名，可以用关键字this区分。

2、this关键字也可以用于在构造函数中调用其他构造函数。但是，只能定义在构造函数的第一行，因为初始化动作要先执行。

3、this是属于对象的，不属于类。

第四章、static关键字

静态变量和静态方法

1、被 static 修饰的变量属于类变量，可以通过类名.类变量调用，而不需要 new 出一个类来。

2、被 static 修饰的方法属于类方法，可以通过类名.类方法调用，而不需要 new 出一个类来。

3、类变量和类方法属于类的静态资源，是实例之间共享的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kIUSt0Pc-1615520177492)(/home/wf/Pictures/static.png)]

1、静态方法能不能引用非静态资源？不能，new的时候才会产生的东西，对于初始化后就存在的静态资源来说，根本不认识它。

2、静态方法里面能不能引用静态资源？可以，因为都是类初始化的时候加载的，大家相互都认识。

3、非静态方法里面能不能引用静态资源？可以，非静态方法就是实例方法，那是new之后才产生的，那么属于类的内容它都认识。

static代码块

static {
	a = 1;
}

类加载的时候执行一次。用于优化程序，提高系统的效率。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7here3lV-1615520177496)(/home/wf/Pictures/JVM.png)]

第五章、代码块

  1. 普通代码块。类中方法的方法体。
  2. 构造代码块。创建对象的时候执行的程序。
  3. static代码块。类加载的时候执行的程序。
  4. 同步代码块。多线程场景中使用的程序。synchronized(){}

第六章、面向对象案例分析

第七章、数组的定义与使用

// 申明的同时创建
int[] arr = new int[10];

// 先申明，且初始化
int[] arr1 = null;
// 再创建
arr1 = new int[20];

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a2AU8Ffq-1615520177499)(/home/wf/Documents/数组.png)]

数组经常会遇到数组越界的异常。当下标超出数组长度时，发生数组越界异常。

异常：程序在运行的过程中出现的问题。比如I/O异常、运行时异常。文件找不到异常，类转换异常、空指针异常，数学异常…

第八章、数据表与简单java类映射转换

1、 数据实体表设计 = 类的定义；

2、表中的字段 = 类的成员属性 ；

3、表的一行记录 = 类的一个实例化对象 ；

4、表的多行记录 = 对象数组 ；

5、表的外键关联 = 引用关联 ；

第十章、String类特点分析

  1. String 类不属于基本数据类型。存储字符串的引用类型，是固定长度的。final修饰，不可继承。

  2. 实例化形式：

    ​ 直接赋值：String str = “wangfei”;内存中有"wangfei"字符串，则不新建对象，若没有，则新建一个对象。

    ​ 构造方法实例化：String str = new String(“wangfei”);两个对象。

  3. 比较：使用equals(String str);基本数据类型使用 == 比较大小，引用类型用equals()比较。实际上equals()方法的内部还是使用 == 比较，但是封装类类型重写了该方法,比如Integer、String等。

  4. 面试题：请解释String类两种对象实例化方式的区别？
    （1）直接赋值：只会产生一个实例化对象，并且可以自动保存到对象池之中，以实现该字符串实例的重用。
    （2）构造方法：会产生两个实例化对象，并且不会自动入池，无法实现对象重用，但是可以使用intern()方法手工入池。

  5. Object 的equals()方法源码。

 public boolean equals(Object obj) {
        return (this == obj);
    }

第十一章、String 类常用方法。

  1. length():返回字符串的长度。数组的长度是length属性，而字符串是length()方法。

  2. equals(String str) ：比较两个字符串内容是否相等。

    ​ 基本数据类型 == 比较的是内容是否相等，而引用类型比较的是hashcode是否相等。

  3. charAt(int index):返回指定下标的字符。

  4. subString(int indexLength):截取字符串。

  5. split(String str):分割字符串。

第十二章、继承的定义与使用(extends关键字)

  1. java 只支持单继承。鉴于单继承这个缺点，java用内部类补充单继承的缺点。使用接口的多实现补充。
  2. 类继承是为了复用其他类的属性和方法（非private修饰的属性和方法）。
  3. 继承的定义与使用（面向对象的第二大特征）
    继承的主要作用在于，在已有的基础上进行功能的扩充操作
    要使用继承，必须要满足“is-a”关系，eg： Student is a Person即满足从属关系

继承使用
子类使用extends继承父类，无须重复编写代码的情况下拥有父类的所有成员。（父类->基类；子类->派生类）

4、继承的使用限制
(1)子类对象在实例化前一定会先实例化父类对象,先调用父类构造方法再调用子类构造方法.
(2)java只允许单继承不允许多继承，一个类只能继承一个父类；不允许多重继承，但可以使用多层继承
(3)在进行继承的时候，子类会继承父类所有的结构（包括私有域）
隐式继承：继承父类所有私有域
显式继承：继承父类的所有非私有域，可以直接调用

第十三章、方法覆写（override）

定义：方法覆写发生在有继承关系的类之间，子类定义了与父类相同的方法（方法名称相同、参数的个数、类型、返回值全部都相同） 被覆写的方法不能拥有比父类更为严格的访问控制权限，即子类不能降低父类的方法访问权限。

存在方法覆写时，到底调用的是哪一个类的同名方法：
a.当前使用的对象是通过哪个类new的
b.调用方法是否被当前对象所在的类覆写，一旦被覆写，一定调用被覆写后的方法。

访问权限
private（仅限本类访问） < default（包访问权限） 同一个源文件中都可以使用< public
子类权限要大于等于父类权限。
方法覆写不能出现private权限

属性覆写（了解）：子类定义了与父类同名的属性

第十四章、综合案例：继承分析

1、继承性的作用
 可以实现类结构的重复利用，可以对类功能进行扩充。
2、优点
 表面上就是减少重复的代码，实际上也是，这个特别舒服，省了复制粘贴
3、缺点
 存在单继承局限性，这个就是说一个子类只能继承一个父类。还有一个缺点就是，父类不能强制性要求子类必须覆写父类中的一些方法(这个敲多代码之后就会慢慢理解)
4、设计继承的原因
 就是实现类结构的重复利用，提高代码的重用性

比如创建一个多线程的类，有两种创建的方式。

1、继承 Thread 类：缺点是该类不能再继承其他类。

2、实现Runable接口:(推荐的方式)，解决 java 单继承的缺点。

第十五章、Annotation注解

public class AnnotationTest {

    @Test
    void test() {
        System.out.println("hahhaa");
    }
}

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration */
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

第十六章、多态性

相同的消息使得不同的类做出不同的响应。

Sun sun = new Sun();
sun.parentMethod1();   //this is a childMethod

WangFei wangFei = new Sun();
wangFei.parentMethod1();//this is a childMethod

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sb3YUxkx-1615520177502)(/home/wf/Pictures/子类与父类的关系.png)]

父类的引用指向了子类的实例，子类重写了父类的方法，则调用执行的是new对象的方法，否则执行父类的当前方法。

第十七章、object类

  1. 首先，Object类是所有类的超类，即是所有类的父类。
  2. 类中定义了equls方法和hashCode方法等。
package java.lang;


public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    
    public final native Class<?> getClass();

    
    public native int hashCode();

    public boolean equals(Object obj) {
        return (this == obj);
    }

   
    protected native Object clone() throws CloneNotSupportedException;

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

  
    public final native void notify();

    public final native void notifyAll();

   
    public final native void wait(long timeout) throws InterruptedException;

    
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }

   
    public final void wait() throws InterruptedException {
        wait(0);
    }

   
    protected void finalize() throws Throwable { }
}

第十八章、抽象类的定义和应用

抽象类定义规则：
1.抽象类和抽象方法必须用abstract关键字来修饰

2.抽象类不能直接实例化，也就是不能直接使用new关键字产生对象,其实，抽象类就是一个模板，具体实现交给子类。

public abstract class People{}

People p = new People(); //错误，People是抽象类，无法实例化
3.抽象方法定义时，只需要声明，不需要实现

public abstract class People{
	public abstract void test();
}

4.含抽象方法的类必须被声明为抽象类，抽象类的子类必须实现所有的抽象方法后，才能被实例化，否则这个子类还是个抽象类.

提示：子类继承父类，也会继承下父类的访问权限为公有的方法，然后子类使用同样的方法名，而执行自己的方法体，我们称为方法的重写(override)，这里我们就注意到，子类在继承抽象类后，我们来完成方法体，用的是“实现”而不是“重写”。

5、抽象类允许有普通方法，但是普通类一定不允许有抽象方法。

需要注意的是:

  • 抽象类可以存在构造方法,用来初始化抽象类的属性,
  • 抽象类不能使用final定义.

第十九章、包装类

java是面向对象语言，但是还是定义了基本数据类型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bfyQGhJm-1615520177504)(/home/wf/Pictures/包装类结构.png)]

第20章、接口的定义与使用

public interface Wangfei {
	public static final int wangfei = 0;
    
    public void test();
}
  1. 接口不能实例化，即使用 new 关键字产生对象。
  2. 通过关键字 implements 实现接口。
  3. 子类或者子接口必须实现父接口的所有方法。
  4. 变量必须使用 static final 修饰。
  5. 方法不能用 {} 方法体，也就意味着只能通过直接子类或者间接子类实现方法。
  6. 方法修饰符必须是 public 或者默认类型。不需要写abstract修饰，内部已经隐式添加 abstract 修饰符。
  7. 无构造方法。
  8. 支持多继承。
  9. 在设计模式中的接口隔离原则是设计模式的七大设计原则之一。接口隔离就是将功能尽可能的具有小的耦合性。
package com.wf.interfacetest;

public interface Base_interface {

    void test1();
    
    void test2();
    
    void test3();
    
    void test4();
    
    
}

package com.wf.interfacetest;

public class Test1 implements Base_interface{
    @Override
    public void test1() {
		System.out.println("this is a test1()");
    }

    @Override
    public void test2() {

    }

    @Override
    public void test3() {

    }

    @Override
    public void test4() {

    }
}

类 test1 只需要 test1() 方法，但是还会实现其他没用的方法，这会造成浪费。

解决方案：定制实现类的接口，即实现类需要哪些功能就创建哪些方法。

第22章、泛型

  1. 泛型是“类型参数化”，即引用类型参数化。
  2. 泛型的参数不能是基本数据类型。因为在参数转化的过程中是将传入的参数转化为 Object 超类。基本数据类型不能转化。
  3. 泛型解决 ClassCastException 类转化异常。
  4. JDK5 提供的编译器类型安全检测机制。
  5. ？ ：表示不确定的 java 类型。
  6. T：表示具体的java类型。
  7. E：表示元素
  8. K,V：表示key value。比如Map<String,Object>.
  9. 上界：<? extends Object>.下界:<? super StringBuilder>。

第23章、包的定义与使用

  1. 包其实就是一个文件夹，用于区分同类。
  2. 命名规则：建议小写。
  3. 限制访问权限。
权限关键字/限制范围publicprotect(默认)private
不同包是否否否
同包是是否否
不同类是是是否
同类是是是是

Java 包的命名规则如下：

  • 包名全部由小写字母（多个单词也全部小写）。
  • 如果包名包含多个层次，每个层次用“.”分割。
  • 包名一般由倒置的域名开头，比如 com.baidu，不要有 www。
  • 自定义包不能 java 开头。

注意：如果在源文件中没有定义包，那么类、接口、枚举和注释类型文件将会被放进一个无名的包中，也称为默认包。在实际企业开发中，通常不会把类定义在默认包下。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-itJmzdqT-1615520177506)(/home/wf/Pictures/类UML.png)]

  • “+” : 表示 public 级别
  • “-”：表示 private 级别
  • “”(省略)：表示包级别
  • “#”：表示 protected 级别
/**
 * @author wf
 */
// 继承/实现
public class Test2 extends Test1 implements Test3{

    // 关联关系
    private Test1 test1;

    // 参数
    public void method(Test1 test2) {
        Test1 test3 = new Test1();


    }
}
class Test1{}
interface Test3{}

第24章、UML

第25章、单例设计模式

class MySingleton{
    // 懒汉式
    private final static MySingleton mySingleton = null;
    // 饿汉式
    private final static MySingleton mySingletonLasy = new MySingleton();
    
    private MySingleton(){}
    
    public synchronized static MySingleton getInstance(){
        return new MySingleton();
    }
    
    public synchronized static MySingleton getInstanceLasy(){
        return mySingletonLasy;
    }
}

为了程序运行的高效，设计出单例模式，有些类或者资源的使用率很高，以前是每次使用都得创建对象，后来 Spring 框架给出了解决方案：IOC 容器。就是将那些常用的类或者资源在系统启动的时候进行创建。使用的时候直接使用。

  • 饿汉式：不用之前就创建资源。(建议)
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}
  • 懒汉式：只有在用的时候再使用。
  • synchronized 修饰的作用：防止多线程的环境下产生多个该对象。

使用场景：

  • 1、要求生产唯一序列号。
  • 2、WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
  • 3、创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

第26章、枚举(enum)

  1. 先定义枚举常量，再定义方法。
  2. EnumMap
  3. EnumSet
package com.wf.enumtest;

import java.util.EnumMap;

public enum WebSite {
    /**
     * 百度
     */
    BAIDU,
    /**
     * 360
     */
    com360,
    /**
     * 新浪
     */
    XINLANG,
    /**
     * 私有
     */
    WF;

    private EnumMap<WebSite,String> enumMap = new EnumMap<>(WebSite.class);

    public void WebSite1(){
        enumMap.put(WebSite.BAIDU,"http://www.baidu.com");

    }


    public String getUrl(WebSite webSite) {
        return this.enumMap.get(webSite);
    }
}

第27章、异常的铺获及处理

Java异常机制用到的几个关键字：try、catch、finally、throw、throws。

try – 用于监听。将要被监听的代码(可能抛出异常的代码)放在try语句块之内，当try语句块内发生异常时，异常就被抛出。
catch – 用于捕获异常。catch用来捕获try语句块中发生的异常。
finally – finally语句块总是会被执行。它主要用于回收在try块里打开的物理资源(如数据库连接、网络连接和磁盘文件)。只有finally块，执行完成之后，才会回来执行try或者catch块中的return或者throw语句，如果finally中使用了return或者throw等终止方法的语句，则就不会跳回执行，直接停止。
throw – 用于抛出异常。
throws – 用在方法签名中，用于声明该方法可能抛出的异常。主方法上也可以使用throws抛出。如果在主方法上使用了throws抛出，就表示在主方法里面可以不用强制性进行异常处理，如果出现了异常，就交给JVM进行默认处理，则此时会导致程序中断执行。

产生异常的原因：

  • 用户输入了非法数据。
  • 要打开的文件不存在。
  • 网络通信时连接中断，或者JVM内存溢出。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UsKtLNbx-1615520177507)(/home/wf/Pictures/异常.png)]

finally块和return

首先一个不容易理解的事实：在 try块中即便有return，break，continue等改变执行流的语句，finally也会执行。
finally中的return 会覆盖 try 或者catch中的返回值。
finally中的return或异常会抑制（消灭）前面try或者catch块中的异常。

第 28 章、内部类

内部类：将一个类嵌入其他类中。称之为内部类。

内部类的优点:

  1. 内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
  2. 内部类是另外一种封装，对外部的其他类隐藏。
  3. 内部类可以实现java的单继承局限。

内部类的缺点:

结构复杂。

内部类可以独立地继承一个抽象类或者实现一个接口，无论外部类是否也这样做了，对内部类都没有影响。

内部类出现的位置

1、成员变量位置

package com.wf.innerclass;

public class Outer {
    class Inner{

    }
}

2、局部位置

package com.wf.innerclass;

public class Outer {
//    class Inner{
//
//    }
    
    
    public void method() {
        class Method_class{
            
        }
    }
}

3、静态内部类

package com.wf.innerclass;

public class Outer {

    static class Inner{
        
    }
}
// 静态内部类无法访问外部类的成员

Outer.Inner inner = new Outer.Inner;访问

4、匿名内部类(使用最多)

特别注意：
在使用匿名内部类时，要记住以下几个原则。
1.匿名内部类不能有构造方法。
2.匿名内部类不能定义任何静态成员，方法和类。
3.匿名内部类不能使用public，protected，private，static。
4.只能创建匿名内部类的一个实例。
5.一个匿名内部类一定时在 new 后面，用其隐含实现一个接口或实现一个类。
6.因匿名内部类为局部内部类，所以，局部内部类的所有限制都对其有效。
7.内部类只能访问外部类的静态变量或静态方法。
8.内部类当中的 this 指的是匿名内部类本身，如果使用外部类中的 this，则“外部类.this”。

第 29 章、函数式编程

函数式接口：有且仅有一个函数的接口。

package com.wf.jdk8;

public interface Inter {
    public void printString();
}

class Show{
    
    public static void main(String[] args) {
        // before JDK8
        Inter inter = new Inter() {
            @Override
            public void printString() {
                System.out.println("哈哈");
            }
        };
        
        // after JDK8
        Inter jdk8 = () -> {
            System.out.println("你好");  
        };
    }
    
}

@FunctionalInterface :注解只是为了表明这是一个函数式接口，函数式接口只能包含一个方法。

@FunctionalInterface
public interface Test{
    boolean method();
}

只能够访问局部对应的外部区域的局部final变量，以及成员变量和静态变量。

但不能修改Lambda域外的局部非final变量

无法访问接口默认（default）方法

第 30 章、链表的定义与使用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AHHo8y7L-1615520177509)(/home/wf/Pictures/链表.png)]

  • 从上面的总结我们可以看出，ArrayList和Vector底层采用的都是数组数据结构，而LinkedList采用的链表的数据结构.
  • 对于插入一个元素到指定的位置，由于ArrayList和Vector采用的是数组的形式，所以需要先将原先的元素进行复制，然后再插入。而LinkedList直接通过改变要插入的节点的指针即可。所以插入元素时，LinkedList比ArrayList和Vector的要快。
  • 对于删除指定位置的元素和插入元素类似，ArrayList和Vector需要进行一次复制然后执行删除，所以没有LinkedList执行的速度快(其实这里是有一点问题的就是我们要删除一个LinkedList中的元素需要先将进行一次查找，然后进行删除，时间复杂度都是O(n)).
  • 对于随机访问，ArrayList和Vector采用数组结构可以根据数组索引进行定位，因此能够快速的访问，而LinkedList最坏的情况可能需要O(n)的时间。
  • 对于Vector因为底层实现的方法都是采用了synchronized方法，所以是线程安全的，而ArrayList和LinkedList则是线程不安全的
  • 对于ArrayList和Vector如果我们不指定初始容量，那么初始化的容量为10，LinkedList初始化为null.
    ArrayList 和Vector的需要扩容机制而LinkedList不需要，ArrayList在添加元素的时候，会判断需要是否需要扩容，如果需要则扩容为之前的1.5倍，而Vector则是扩容为之前的2倍。

Set和List的区别

    1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
    1. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
    1. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

第 31 章、List 集合

  1. List接口继承自顶层容器 Collection 接口。

  2. list 代表列表的意思。

  3. 常用的列表是 ArrayList、LinkedList。

  4. ArrayList 底层使用数组和链表实现数据的存储，内容是无序，可能重复的。特点是检索速度快，因为数据在内存中是连续的，即物理上是连续存储。

  5. ArrayList源码解析

    总结：
    (01) ArrayList 实际上是通过一个数组去保存数据的。当我们构造ArrayList时；若使用默认构造函数，则ArrayList的默认容量大小是10。
    (02) 当ArrayList容量不足以容纳全部元素时，ArrayList会重新设置容量：新的容量=“(原始容量x3)/2 + 1”。
    (03) ArrayList的克隆函数，即是将全部元素克隆到一个数组中。
    (04) ArrayList实现java.io.Serializable的方式。当写入到输出流时，先写入“容量”，再依次写入“每一个元素”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

  6. LinkedList

第 32 章、Set 集合

第 33 章、集合输出

for

foreach

Iterator

第 34 章、map集合

Map<K,V> hashMap = new HashMap<>();

  1. HashMap:这也是我们平时开发中最常用的map，底层实现为数组+链表，它根据键key的HashCode值存储数据，可以使用get(key)来获取键对应的值，是线程不安全的。HashMap允许存在一条键为null的记录。在数据量小的时候，HashMap是以链表的模式存储数据；当数据量变大后，为了进行快速查找，会将这个链表变为红黑树来进行保存，使用key的哈希值来进行查找。

  2. TreeMap:该map将存储的键值对进行默认排序，并且还能够指定排序的比较器，是线程不安全的。TreeMap不允许键值为null。

  3. Hashtable:与HashMap类似，不同的是，Hashtable是线程安全的，在进行插入是会比HashMap慢，并且key和value的值均不允许为null。对个线程同时访问Hashtable对象时，第一个线程获取锁后，会引发其他线程进行等待，知道第一个线程释放掉锁。

  4. LinkedHashMap：该map保证了对面在插入值得顺序，在查询遍历的时候会比HashMap慢，是线程不安全的。允许key和value均为空。

  5. ConcurrentHashMap:该map对象时线程安全的，与Hashtable不同的是，ConcurrentHashMap采用了分段锁技术，没有同Hashtable一样锁住全部数据，而是锁定线程访问的那一段数据。对个线程在访问不同段数据时就不会存在等待。

  6. ConcurrentHashMap的主干是Segment数组。没有Segment就相当于一个小的HashTable，知道不修改访问同一个Segment上的数据就不会存在并发问题。

  7. Segment是一种可重入锁，继承ReentranLock类。下面简单介绍一下ReentranLock与synchronized的区别：

    • Synchronized是一个同步锁。当一个线程A访问synchronized修饰的代码块时，线程A就会获取该代码块的锁，如果这时存在其他线程范围该代码块时，将会阻塞，但是不影响这些线程访问其他非同步代码块。
    • ReentranLock是可重入锁。由构造方法可知，该锁支持两种锁模式，公平锁和非公平锁。默认是非公平的。

  8. 公平锁：当线程A获取访问该对象，获取到锁后，此时内部存在一个计数器num+1，其他线程想访问该对象，就会进行排队等待(等待队列最前一个线程处于待唤醒状态)，直到线程A释放锁(num = 0)，此时会唤醒处于待唤醒状态的线程进行获取锁的操作，一直循环。如果线程A再次尝试获取该对象锁是，会检查该对象锁释放已经被占用，如果被占用，会做一次是否为当前线程占用锁的判断，如果是内部计数器num+1，并且不需要进入等待队列，而是直接回去当前锁。

  9. 非公平锁：当线程A在释放锁后，等待对象的线程会进行资源竞争，竞争成功的线程将获取该锁，其他线程继续睡眠。

  10. 公平锁是严格的以FIFO的方式进行锁的竞争，但是非公平锁是无序的锁竞争，刚释放锁的线程很大程度上能比较快的获取到锁，队列中的线程只能等待，所以非公平锁可能会有“饥饿”的问题。但是重复的锁获取能减小线程之间的切换，而公平锁则是严格的线程切换，这样对操作系统的影响是比较大的，所以非公平锁的吞吐量是大于公平锁的，这也是为什么JDK将非公平锁作为默认的实现。

    对于Map的遍历，建议使用entrySet迭代器方式，在进行大量级数据时，效率会高很多。

第 35 章、集合工具类

https://doc.bccnsoft.com/docs/jdk8u12-docs/api/

第 36 章、Stream 数据流

https://doc.bccnsoft.com/docs/jdk8u12-docs/api/

小飞LOVE霞
关注
【java】继承与单继承局限
qq_43464809的博客
03-31 2198
继承 :继承描述的是一种能力,可以使用现有类的所有功能,并在无需重新编写原来的类的情况下对这些功能进行扩展。 要使用继承,必须满足is-a原则.(代码复用性) 继承使用extends eg:Student,extends,person 继承语法:子类 extends 父类 (子类使用extends来继承父类) 子类:派生类,子类一定具有父类的全部属性与行为,并且与父类相比,拥有的属性更多,具有的行...
［JavaSE］接口--------如何有效避免java开发中的单继承局限
weixin_42645168的博客
03-28 458
预备知识： 多态、内部类知识点总结（向上、向下转型） 浅谈抽象类-------------普通类的超集 目录 接口 子类继承抽象类实现接口： 接口的应用： 抽象类和接口的区别： 接口 定义：抽象方法和全局常量的集合，在java中用interface关键字定义 eg.定义一个简单的接口 interface IMessage{ public static final ...
多线程基础
u012222011的博客
05-22 367
程序进程线程 在操作系统中的运行的程序就是进程，而进程通常采用多进程执行 程序 指令和数据的有序集合，本身没有任何运行的含义，是静态概念 进程 是执行程序的一次执行过程，是一个动态概念，是系统资源分配的单位 线程 一个进程通常包括多个线程，线程是CPU调度和执行的单位 run()方法是需要执行的方法体 start()方法是开启多线程的方法体 Thread 类 不建议使用：避免OOP单继承局限性 1.thread使用方法 自定义线程类继承T..
java游戏继承_Java继承的实现与继承限制分析
weixin_39808877的博客
02-26 110
本文实例讲述了Java继承的实现与限制。分享给大家供大家参考，具体如下：Java继承的实现继承的实现1.继承的基本概念扩展父类的功能2.Java中使用extends关键字完成继承。示例代码:public class ExtendsDemo01 {static class Person{private int age;private String name;public int getAge() {...
java内部类可以弥补java的单继承局限
不止于代码
11-08 338
java中，内部类和接口的使用都可以弥补java的单继承局限 示例： 输出：aaa,bbb package com.clc.myapplication; public class Main { public static void main(String[] args) { Out out = new Out(); System.out.print...
[Java]小记Java的多个set处理的代码闲聊
qq_28033719的博客
03-30 1809
一、 一开始有段代码想看下怎么优化，原来是这样的： public Map<String, Object> test() { Map<String, Object> resMap = new LinkedHashMap<>(); List list = new ArrayList<>(); int a1 = 0; int a2 = 0; int a3 = 0
java输出windows系统日志_闲聊Windows系统日志
weixin_31585653的博客
03-02 2107
title: "闲聊Windows系统日志"date: 2021-02-22T18:59:49+08:00draft: truetags: ['windows']author: "dadigang"author_cn: "大地缸"personal: "http://www.real007.cn"闲聊Windows系统日志2018-07-302018-07-30 17:38:54阅读 4.2K0\ ...
如何用Java实现ai闲聊
04-30
要用Java实现AI闲聊，可以使用机器学习或者深度学习算法，以及一些NLP（自然语言处理）技术。以下是一个简单的实现方法： 1. 收集数据集：首先需要一个数据集，它应该包含足够的对话，可以从网上或者其他渠道收集。...
基于mirai-core的Java开发框架(内置签到、运势、灵签、笑话、闲聊等功能）.zip
03-24
【标题】: "基于Mirai-Core的Java开发框架——实现签到、运势、灵签、笑话及闲聊功能" 在当前的互联网应用开发中，框架的使用极大地提高了开发效率和代码质量。本项目是一个基于Mirai-Core的Java开发框架，它提供了...
调用腾讯智能闲聊 ai java python itchat腾讯机器人
weixin_43299649的博客
04-11 2245
这里写自定义目录标题欢迎使用Markdown编辑器pom.xmlMD5Util.javaSign.java 签名鉴权实体Application.javaController.javademo地址https://gitee.com/sw521/Tencentdemo.git 欢迎使用Markdown编辑器 pom.xml <?xml version="1.0" encoding="UTF-...
java 开启线程的三种方法（Runnable如何避免单继承局限性）
weixin_44423896的博客
09-01 588
public class runThread extends Thread{ @Override public void run() { for (int i=0;i<10;i++){ System.out.println("重写run方法线程开启"); } } } public class runnableThread implements Runnable{ @Override public voi
Java单继承经典面试题
热门推荐
niaonao
04-01 1万+
一、面试题 面试题 LVXQ.java 代码如下public class LJXQ { public static void main(String[] args) { A a = new A(); B b = new B(); C c = new C(); D d = new D(); System.out.println(a.get(a) + " - " + a....
Java继承的限制
whyzzdd1126的博客
06-25 317
Java继承的限制 主要写Java中继承的限制 1、在Java中只允许单继承。 2、子类不能直接访问父类的私有成员。 /** 继承的限制 java 不运行多继承, 也就是只能继承一个类, 但是其父类可以再继承一个类 继承具有传递性 */ public class Inheritence2 { public static void main(String[] args) { //生出一个儿子 Child son=new Child(); } } class ChinesePeop
区别:1 继承有局限性，java中只能单继承2.继承Thread类的方式，数据是线程独享的
Enjoy life,Enjoy coding!!
01-10 1928
package com.mth.test3; /* * getName()获得线程名字 * setName()设置线程名字 * * */ public class ThreadTest4 extends Thread { private int tickets = 20; @Override public void run() { while (tickets > 0)
小白勿进！程序员跳槽时机已到，闲聊中面试官无意泄题
m0_57699613的博客
06-15 1110
前言 疫情控制期间空虚寂寞？正值跳槽旺季，不如来备战“金三银四” 近日和一位大厂面试官（同时也是知名博主）闲聊，得知不少某厂关于2020春招面试时的提问和答案。 上周，本来跟他聊公众号内容合作，聊着聊着便说到了金三银四的面试情况。他说刚面试了一个来应聘java高级开发的人，此人学历很高，也做了几年Java。问到myisam与innodb的区别都能对答如流，varchar与char的区别以及varchar(50)中的50代表的涵义也是答得出来。当问到InnoDB支持的四种事务隔离级别名称，以及逐级之间的区别时
spring事务详细讲解-深入浅出
小电玩
09-08 538
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1521
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 586
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 618
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小飞LOVE霞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值