MESSIR22
MESSIR22

java基础

java文件结构快速了解

Java 文件的基本结构

一个简单的Java文件通常包含以下几个部分：

  1. 包声明：

    • 每个Java源文件都属于某个包。包的作用类似于文件夹，用于组织和分类相关的类。
    • 示例：package com.example;

  2. 导入语句：

    • 导入语句用于引入其他包中的类或接口，这样可以在当前文件中直接使用这些类或接口。
    • 示例：import java.util.ArrayList;

  3. 类声明：

    • 类是Java程序的基本构建块。每个类定义了一组属性（变量）和方法（函数）。

    • 示例：

      public class HelloWorld {
    // 类体
}

  4. 构造方法：

    • 构造方法是一种特殊的方法，用于创建类的新实例时初始化对象。

    • 示例：

      public HelloWorld() {
    // 初始化代码
}

  5. 属性（成员变量）：

    • 属性是类中存储数据的变量。

    • 示例：

      private String name;

  6. 方法：

    • 方法是执行特定任务的代码块。

    • 示例：

      public void sayHello() {
    System.out.println("Hello, World!");
}

  7. 主方法（main方法）：

    • 主方法是Java应用程序的入口点。当程序启动时，JVM会寻找并执行这个方法。

    • 示例：

      java深色版本

      public static void main(String[] args) {
    HelloWorld hello = new HelloWorld();
    hello.sayHello();
}

示例代码

以下是一个完整的Java文件示例，结合了上述各个部分：

java深色版本

// 包声明
package com.example;

// 导入语句
import java.util.ArrayList;

// 类声明
public class HelloWorld {

    // 成员变量
    private String name;

    // 构造方法
    public HelloWorld() {
        this.name = "World";
    }

    // 普通方法
    public void sayHello() {
        System.out.println("Hello, " + name);
    }

    // 主方法
    public static void main(String[] args) {
        HelloWorld hello = new HelloWorld();
        hello.sayHello();
    }
}

使用 IntelliJ IDEA (IJ)

  1. 创建新项目：
    • 打开IJ，选择“File” -> “New” -> “Project”，选择Java项目，点击“Next”完成项目创建。
  2. 创建新类：
    • 在项目的src目录下右键，选择“New” -> “Java Class”，输入类名（如HelloWorld），然后点击“OK”。
  3. 编写代码：
    • 在打开的编辑器窗口中，输入上述示例代码。
  4. 运行程序：
    • 右键点击编辑器中的类文件，选择“Run ‘HelloWorld.main()’”来运行程序。
    • 或者点击工具栏上的绿色三角形按钮运行程序。

包和import

在Java中，包（package）是用来组织类和接口的一种机制，类似于文件系统的文件夹结构。导入（import）语句则允许你在当前类中使用其他包中的类或接口。下面详细介绍如何声明包和导入其他包中的类，并附带例子。

如果一个保重的类要想被其他包中的类所使用，那么这个类一定要定义为public class，而不嫩使用class声明，因为class声明的类只能够在同一个包中使用 。

public class：文件名称和类名称保持一致，在一个.java文件中只能存在一个public class定义，如果一个类要想被外部的包所访问必须定义为public。*

*class:文件名称可以和类名称不一致，在一个*java中可以同时存在多个class定义，并且编译完成之后会形成多个 .class文件，使用class定义的类只能够在一个包中访问，不同包无法访问

包的本质是目录

1. 声明包

每个Java源文件都可以属于一个包。包声明必须是源文件中的第一行非注释代码。语法如下：

package 包名;

例如，如果你希望将你的类放在 com.example 这个包中，可以在文件的开头这样声明：

package com.example;

2. 导入其他包中的类

单个类导入

如果你想导入某个包中的单个类，可以使用以下语法：

import 包名.类名;

例如，如果你想导入 java.util 包中的 ArrayList 类，可以这样写：

import java.util.ArrayList;
多个类导入

如果你想导入某个包中的多个类，可以逐个导入，也可以使用通配符 * 导入整个包中的所有类。语法如下：

import 包名.*;

例如，如果你想导入 java.util 包中的所有类，可以这样写：

import java.util.*;
注：
在java中无论使用"import 包.*" 导入或者是单独导入，从实际的操作性能上来讲是没有任何区别的，因为即使使用了"*"也表示只导入所需要的类，不需要的并不导入。

3. 静态导入

静态导入允许你直接使用类中的静态成员（方法或变量），而不需要指定类名。语法如下：

import static 包名.类名.静态成员名;

例如，如果你想导入 Math 类中的 PI 常量和 sqrt 方法，可以这样写：

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;

然后你可以在代码中直接使用 PI 和 sqrt，而不需要前缀 Math：

double result = sqrt(16) * PI;

完整示例

假设你有一个项目结构如下：

src/
├── com/
│   └── example/
│       ├── Main.java
│       └── Person.java
Person.java
package com.example;

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

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}
Main.java
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));

        for (Person person : people) {
            System.out.println(person);
        }
    }
}

解释

  1. 包声明：
    • Person.java 和 Main.java 都声明了 package com.example;，表示它们属于 com.example 包。
  2. 导入语句：
    • Main.java 中导入了 java.util.ArrayList 和 java.util.List，以便在代码中使用这些类。
  3. 类和方法：
    • Person 类定义了一个简单的 Person 对象，包含姓名和年龄。
    • Main 类中的 main 方法创建了一个 Person 对象列表，并打印每个对象的信息。

总结注：

如果同时导入了不同包中名称相同的类，这时候就使用的时候就需要使用这个类的完整名称。

如：hh.gg.util.Message msg = new hh.gg.util.Message();

利用静态导入的优点在于，不同类的静态方法就好像在主类定义的一样，不需要类名称就可以直接进行调用。

jar文件

java中的压缩文件格式，即可以将*class文件以 *jar压缩包的形式给用户。

jar --help
用法: jar [OPTION...] [ [--release VERSION] [-C dir] files] ...
jar 创建类和资源的档案, 并且可以处理档案中的
单个类或资源或者从档案中还原单个类或资源。

 示例:
 # 创建包含两个类文件的名为 classes.jar 的档案:
 jar --create --file classes.jar Foo.class Bar.class
 # 使用现有的清单创建档案, 其中包含 foo/ 中的所有文件:
 jar --create --file classes.jar --manifest mymanifest -C foo/ .
 # 创建模块化 jar 档案, 其中模块描述符位于
 # classes/module-info.class:
 jar --create --file foo.jar --main-class com.foo.Main --module-version 1.0
     -C foo/ classes resources
 # 将现有的非模块化 jar 更新为模块化 jar:
 jar --update --file foo.jar --main-class com.foo.Main --module-version 1.0
     -C foo/ module-info.class
 # 创建包含多个发行版的 jar, 并将一些文件放在 META-INF/versions/9 目录中:
 jar --create --file mr.jar -C foo classes --release 9 -C foo9 classes

要缩短或简化 jar 命令, 可以在单独的文本文件中指定参数,
并使用 @ 符号作为前缀将此文件传递给 jar 命令。

 示例:
 # 从文件 classes.list 读取附加选项和类文件列表
 jar --create --file my.jar @classes.list


 主操作模式:

  -c, --create               创建档案
  -i, --generate-index=FILE  为指定的 jar 档案生成
                             索引信息
  -t, --list                 列出档案的目录
  -u, --update               更新现有 jar 档案
  -x, --extract              从档案中提取指定的 (或全部) 文件
  -d, --describe-module      输出模块描述符或自动模块名称
      --validate             Validate the contents of the jar archive. This option
                             will validate that the API exported by a multi-release
                             jar archive is consistent across all different release
                             versions.

 在任意模式下有效的操作修饰符:

  -C DIR                     更改为指定的目录并包含
                             以下文件
  -f, --file=FILE            档案文件名。省略时, 基于操作
                             使用 stdin 或 stdout
      --release VERSION      将下面的所有文件都放在
                             jar 的版本化目录中 (即 META-INF/versions/VERSION/)
  -v, --verbose              在标准输出中生成详细输出

 在创建和更新模式下有效的操作修饰符:

  -e, --main-class=CLASSNAME 捆绑到模块化或可执行
                             jar 档案的独立应用程序
                             的应用程序入口点
  -m, --manifest=FILE        包含指定清单文件中的
                             清单信息
  -M, --no-manifest          不为条目创建清单文件
      --module-version=VERSION    创建模块化 jar 或更新
                             非模块化 jar 时的模块版本
      --hash-modules=PATTERN 计算和记录模块的散列,
                             这些模块按指定模式匹配并直接或
                             间接依赖于所创建的模块化 jar 或
                             所更新的非模块化 jar
  -p, --module-path          模块被依赖对象的位置, 用于生成
                             散列

 只在创建, 更新和生成索引模式下有效的操作修饰符:

  -0, --no-compress          仅存储; 不使用 ZIP 压缩
      --date=TIMESTAMP       The timestamp in ISO-8601 extended offset date-time with
                             optional time-zone format, to use for the timestamps of
                             entries, e.g. "2022-02-12T12:30:00-05:00"

 其他选项:

  -?, -h, --help[:compat]    提供此帮助，也可以选择性地提供兼容性帮助
      --help-extra           提供额外选项的帮助
      --version              输出程序版本

 如果模块描述符 'module-info.class' 位于指定目录的
 根目录中, 或者位于 jar 档案本身的根目录中, 则
 该档案是一个模块化 jar。以下操作只在创建模块化 jar,
 或更新现有的非模块化 jar 时有效: '--module-version',
 '--hash-modules' 和 '--module-path'。

 如果为长选项提供了必需参数或可选参数, 则它们对于
 任何对应的短选项也是必需或可选的

抽象类

一.关键字及定义
抽象类使用abstrat class进行定义，并且在一个抽象类中也可以利用abstract关键词定义若干个抽象方法，这样抽象类的子类就必须在继承抽象类时强制覆写全部抽象方法。

抽象类并不是一个完整的类，对于抽象类的使用需要按照以下原则进行。

​ ----抽象类必须提供有子类，子类使用extends继承一个抽象类

​ ----抽象类的子类（不是抽象类）一定要覆写抽象类的全部抽象方法。

​ ----抽象类的对象实例化可以利用对象多态性通过子类向上转型的方法完成

二.抽象类的相关说明（有参无参构造）

​ (1) 抽象类必须由子类继承，所以在定义时，不允许使用final关键字定义抽象类或抽象方法。

补充final关键字

final修饰的类不能被继承。
final修饰的方法不能被子类重写。
final修饰的变量只能被赋值一次，且对于引用类型来说，是指向的地址不能变，但对象的状态可以改变。
final变量可以提高并发程序的安全性和性能。

​ (2) 抽象类中可以定义成员属性与普通方法，为了可以为抽象类中的成员属性初始化，可以在抽象类中提供构造方法。子类在继承抽象类时会默认调用父类的无参构造，如果抽象类没有提供无参构造方法，则子类必须通过super()的形式调用指定参数的构造方法。

代码示例

abstract class Message{
    private String type;//消息类型
    public Message(String type) {
        this.type = type;
    }
    public abstract String getConnectionInfo();
    public String getType(){
        return type;
    }
}

class DatabaseMessage extends Message{
    public DatabaseMessage(String type){
        super(type);//调用单参构造。
    }
    @Override
    public String getConnectionInfo() {
        return "[" + super.getType() +"]数据库连接信息。";

    }
}



public class JavaDome {
    public static void main(String[] args) {
        Message message = new DatabaseMessage("Java");//向上转型
        System.out.println(message.getConnectionInfo());
    }
}

这里补充些有参无参构造知识

抽象类：
抽象类是不能被实例化的类，它通常包含一个或多个抽象方法（没有具体实现的方法）。
抽象类可以包含成员属性、普通方法和构造方法。

构造方法：
构造方法用于初始化对象的属性。
抽象类中的构造方法可以用于初始化抽象类中的成员属性。

子类继承抽象类
当一个子类继承抽象类时，子类的构造方法会自动调用父类的构造方法。具体规则如下：

​ 默认调用无参构造方法：

如果父类有无参构造方法，子类的构造方法会默认调用父类的无参构造方法。
如果父类没有无参构造方法，子类必须显式调用父类的有参构造方法。

​ 显式调用有参构造方法：

如果父类只有有参构造方法，子类必须在构造方法中使用 super() 显式调用父类的有参构造方法。
super() 必须是子类构造方法中的第一条语句。

注：

  如果你在抽象类中定义了有参构造方法，而没有定义无参构造方法，那么编译器不会自动生成默认的无参构造方法。这意味着子类在继承该抽象类时，必须显式调用父类的有参构造方法。

默认无参构造方法：
  在Java中，如果你没有定义任何构造方法，编译器会自动为你生成一个无参构造方法。这个无参构造方法是默认的，不带任何参数。

自定义构造方法：
  一旦你定义了任何一个构造方法（无论是有参还是无参），编译器就不会再生成默认的无参构造方法。因此，如果你需要无参构造方法，必须显式地定义它。

​ (3) 抽象类中允许没有抽象方法，即便没有抽象方法。也无法直接使用关键字new直接实例化抽象类对象

​ (4) 抽象类中可以提供static方法，并且该类方法不受到抽象类实例化对象的限制。

代码示例

abstract class Message{
    public abstract String getInfo();
    public static Message getInstance(){
        return new DatabaseMessage();
    }
}
class DatabaseMessage extends Message{
    @Override
    public String getInfo(){
        return "hello";
    }
}


public class JavaDome1 {
    public static void main(String[] args) {
        Message msg = Message.getInstance();//静态直接调用
        System.out.println(msg.getInfo());
    }
}

包装类

这里就演示一个double类型的装箱和拆箱

public class JavaDemo{
	public static void main(String args[]){
		Double obj = new Double(10.1);//装箱
		double num = obj.doubleValue();//拆箱
		System.out.println(num*num);
	}
}

//其他包装的基本数据类型是同理

注：

JDK1.5以前是必须的操作，JDK1.5之后，java提供了自动装箱和拆箱机制，并且包装类的对象可以自动进行数学计算了。
JDK1.9出现了过期声明。也就说明后面的都是自动装箱。

自动装箱

public class JavaDome{
	public static void main(String args[]){
		Integer obj = 10;//自动装箱，无需关注构造方法了。
		int num = obj;//自动拆箱，等价于调用了intValue()方法。
		obj++;//包装类对象可以直接参与数学运算。
		System.out.println(num*obj);
	}
}

接口

定义

​ 接口在实际开发中是由一种比抽象类更为重要的结构组成，接口的主要特点在于其用于定义开发标准，同时接口在JDK1.8之后也发生了重大变革。

关键字

interface

java中接口属于一种特殊的类，需要通过interface关键字进行定义，在接口中可以定义全局常量、抽象方法（必须是public访问权限）、default方法以及static方法。

接口中的方法默认是抽象的。

示例

//由于类名称与接口名称的定义要求相同，所以为了区分出接口，往往会在接口名称前加入字母I（interface）
interface IMessage{							//定义接口
	public static final String INFO = "hh";//全局变量
	public abstract String getInfo();//抽象方法
}

本程序定义一个IMessage接口，由于接口中存在有抽象方法，所以无法被直接实例化。其使用规则如下。
	接口需要被子类实现，子类利用implements关键字可以实现多个父接口
	子类如果不是抽象类，那么一定要覆写接口中的全部抽象方法
	接口对象可以利用子类对象的向上转型进行实例化
注：
子类可以继承父类也可以实现父接口，其基本语法如下:

class 子类[extends 父类][implements 接口1,接口2，...]{}


如果出现混合应用，则要采用先继承(extends)再实现(implements)的顺序完成，同时一定要记住，子类接口的最大特点在于可以同时实现多个父接口，而每一个子类只能通过extends继承一个父类

感觉写法上跟继承差不多

接口的转型

​ 接口和Object之间没有任何关系，但是如果有子类实现了这些接口和默认继承了Object父类，所以该子类向上转型的实例就可以进行任意父类接口转型。

接口的简化定义

​ 在进行接口定义时，对于全局常量和抽象方法可以按照一下形式简化

interface IMessage{
	public static final String INFO = "gg";
	public abstract String getInfo();
}

//简化定义
interface IMessage{
	String INFO = "gg";
	String getInfo();
}

作用完全相同，但是建议保留public，这样定义会更清楚

​ 在面向对象的设计中，抽象类是一种必不可少的结构，利用抽象类可以实现一些公共方法的定义。可以利用extends先继承父类再利用implements实现若干父接口的顺序完成子类的定义。

在Java中，接口中的成员属性（字段）默认是 public、static 和 final 的。这意味着：

公共的（public）：可以在任何地方访问。
静态的（static）：属于接口本身，而不是接口的实例。可以通过接口名称直接访问这些字段。
最终的（final）：一旦赋值后不能更改。
因此，接口中的成员属性实际上是常量，通常用于定义一些固定的值，供实现该接口的类使用。

extends继承多个父接口

​ java中的extends关键字除了具有类继承作用以外，也可以在接口上使用以实现接口的继承关系，并且可以同时实现多个父接口。

示例

interface Imessage{
	public static final String INFO = "hh";//全局常量
	public abstract String getInfo();
}
interface IChannel{
	public boolean connect();//抽象方法
}

//extends在类继承上只能够继承一个父类，但是接口上可以继承多个。
interface IService extends IMessage,IChannel{
	public String service();
}
class MessageService implement IService{
	@Override
	public String getInfo(){
		return IMessage.INFo;
	}
	@Override
	public boolean connect(){
		return true;
	}
	@Override
	public String service(){
		return "hello";
	}
}

接口定义的加强（default、static）

JDK1.8以后，接口中的组成出了提供全局常量和抽象方法之外。还可以使用default定义普通方法或者使用static定义静态方法

interface IMessage{
	public String message();//抽象方法
	public default boolean connect(){	//普通方法，可以被子类继承和覆写
		System..out.println("建立");
		return true;
	}
}
class MessageImpl implements IMessage{
	public String message(){
		return "hh";
	}
}

public class JavaDome{
	public static void main(){
		IMessage msg = new MessageImpl();
		if(msg.connect()){
			System.out.println(msg.message());
		}
	}
}
static

使用default定义的普通方法需要通过接口实例化对象才可以调用，而为了避免实例化对象的依赖。在接口中也可以使用static定义的方法，此方法可以直接利用接口名称调用。

注：
接口在整体设计上是针对类的进一步抽象，其设计层次也要高于抽象类99

设计模式

工厂设计模式

最终最好都是用工厂设计模式来获取实例对象

class Factory{
	public static IEat getInstance(){
		return new EatProxy(new EatReal());
	}
}


public class JavaDome{
	public static void main(Sring arg[]){
		IEat eat = Factory.getInstance();
		eat.get();
	}
}
代理设计模式
No. 区别 抽象类 接口
1 关键字 abstract、class interface
2 组成 常量、变量、抽象方法、普通方法、构造方法 全局常量、抽象方法、普通方法、静态方法
3 权限 可以使用各种权限 只能是public
4 关系 一个抽象类可以实现多个接口 接口不能够继承抽象类，却可以继承多接口
5 使用 子类使用extends继承抽象类、抽象类和接口的对象都是利用对象多态性的向上转型，进行接口或者抽象类的实例化操作 子类使用implements实现接口、抽象类和接口的对象都是利用对象多态性的向上转型，进行接口或者抽象类的实例化操作
6 设计模式 模版设计模式 工厂设计模式、代理设计模式
7 局限 一个子类只能继承一个抽象类 一个子类可以实现多个接口

泛型

泛型设计的核心思想在于：类中的属性或方法的参数与返回值的类型采用动态标记，在对象实例化的时候动态配置于鏊使用的数据类型

泛型可以定义在任意的程序结构体中

泛型是Java中的一种强大特性，它允许你在定义类、接口和方法时使用类型参数，从而提高代码的复用性和类型安全性。以下是关于泛型的一些关键点和示例：

泛型的基本概念

  1. 类型参数：用大写字母表示，如 T、E、K、V 等。
  2. 泛型类：使用类型参数定义类。
  3. 泛型接口：使用类型参数定义接口。
  4. 泛型方法：使用类型参数定义方法。
  5. 泛型集合：使用泛型来指定集合中存储的元素类型。

泛型类

public class Box<T> {
    private T item;

    public Box(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    public void setItem(T item) {
        this.item = item;
    }
}

public class Test {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>("Hello");
        System.out.println(stringBox.getItem()); // 输出: Hello

        Box<Integer> integerBox = new Box<>(123);
        System.out.println(integerBox.getItem()); // 输出: 123
    }
}

泛型接口

public interface Container<T> {
    void add(T item);
    T get(int index);
}

public class ArrayListContainer<T> implements Container<T> {
    private List<T> list = new ArrayList<>();

    @Override
    public void add(T item) {
        list.add(item);
    }

    @Override
    public T get(int index) {
        return list.get(index);
    }
}

public class Test {
    public static void main(String[] args) {
        Container<String> stringContainer = new ArrayListContainer<>();
        stringContainer.add("Hello");
        System.out.println(stringContainer.get(0)); // 输出: Hello

        Container<Integer> integerContainer = new ArrayListContainer<>();
        integerContainer.add(123);
        System.out.println(integerContainer.get(0)); // 输出: 123
    }
}

泛型方法

public class Util {
    public static <T> void printArray(T[] array) {
        for (T item : array) {
            System.out.print(item + " ");
        }
        System.out.println();
    }
}

public class Test {
    public static void main(String[] args) {
        String[] stringArray = {"Hello", "World"};
        Util.printArray(stringArray); // 输出: Hello World

        Integer[] integerArray = {1, 2, 3};
        Util.printArray(integerArray); // 输出: 1 2 3
    }
}

泛型约束

你可以使用泛型约束来限制类型参数的范围，确保传入的类型满足某些条件。

public class Box<T extends Number> {
    private T item;

    public Box(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }

    public void setItem(T item) {
        this.item = item;
    }

    public double getDoubleValue() {
        return item.doubleValue();
    }
}

public class Test {
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>(123);
        System.out.println(integerBox.getDoubleValue()); // 输出: 123.0

        // Box stringBox = new Box<>("Hello"); // 编译错误，String 不是 Number 的子类
    }
}

通配符

通配符 ? 用于表示未知类型，可以进一步限定其范围。

  • 无界通配符：表示未知类型。
  • 上界通配符：表示类型是T 或其子类。
  • 下界通配符：表示类型是T 或其父类。
public class Util {
    public static void printList(List<?> list) {
        for (Object item : list) {
            System.out.print(item + " ");
        }
        System.out.println();
    }

    public static void addNumbers(List<? super Integer> list) {
        list.add(1);
        list.add(2);
    }
}

public class Test {
    public static void main(String[] args) {
        List<Object> objectList = new ArrayList<>();
        Util.addNumbers(objectList);
        Util.printList(objectList); // 输出: 1 2

        List<Number> numberList = new ArrayList<>();
        Util.addNumbers(numberList);
        Util.printList(numberList); // 输出: 1 2
    }
}

总结

  • 泛型类：使用类型参数定义类，提高代码复用性和类型安全性。
  • 泛型接口：使用类型参数定义接口，增强接口的灵活性。
  • 泛型方法：使用类型参数定义方法，使方法更加通用。
  • 泛型约束：限制类型参数的范围，确保类型安全。
  • 通配符：处理不确定类型的场景，增强代码的灵活性。
注：
在面向对象的程序设计中,Object类可以接收一切的数据类型。但是在泛型的概念中：Message<String>与Message<Object>属于两个不同的类型。
辨析两种细节：
1.public static void fun(Message<Object> temp){}
2.public static void fun(Message temp){}

//使用1这种方式定义接收参数，表示fun()方法只能够接收Message类型的引用

//使用2这种方式定义接收参数，不在fun()方法上设置泛型类型，实际上可以解决不同泛型类型的对象传递问题，但同时也会有新的问题产生：允许随意修改数据
---示例：
	public class JavaDemo{
		public static void main(String args[]){
			Message<String> msg = new Message<String>();
			msg.setContent("hh");
			fun(msg);
		}
	}
	//不设置泛型类型，表示可以接收任意的泛型类型对象
	//默认泛型类型为Object,但不等同于Message
	public static void fun(Message temp){
		//原始类型为String,现在设置Interger
		temp.setContent(18);
		System.out.println(temp.getContent());
	}
	//虽然可以接收，但是无法对修改做出控制，而使用通配符"?"的泛型只允许获取，不允许修改。
 
  
泛型约束
 
  
 
   
类和方法
 
  
 
  
设置泛型的上限(?extends类)：只能够使用当前类或者当前类的子类设置泛型类型。
?extends Number:可以设置Number或Number子类（例如Integer、Double）

 
  
 
   
方法
 
  
 
  
设置泛型的下线(?super类)：只能够设置指定的类或者指定类的父类。
?super String:只能够设置String或String的父类Object

 
  
泛型接口
 
  
泛型接口在进行子类定义时就有两种实现方式：在子类中继续声明泛型和子类中为父类设置泛型类型

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,java,开发语言)

        

            

                
    
                    
  • JSON 与 AJAX
                        Auscy
jsonajax前端
                        
    一、JSON（JavaScriptObjectNotation）1.数据类型与语法细节支持的数据类型：基本类型：字符串（需用双引号）、数字、布尔值（true/false）、null。复杂类型：数组（[]）、对象（{}）。严格语法规范：键名必须用双引号包裹（如"name":"张三"）。数组元素用逗号分隔，最后一个元素后不能有多余逗号。数字不能以0开头（如012会被解析为12），不支持八进制/十六进制
    
                    
    • 
                    
  • JavaScript 树形菜单总结
                        Auscy
microsoft
                        
    树形菜单是前端开发中常见的交互组件，用于展示具有层级关系的数据（如文件目录、分类列表、组织架构等）。以下从核心概念、实现方式、常见功能及优化方向等方面进行总结。一、核心概念层级结构：数据以父子嵌套形式存在，如{id:1,children:[{id:2}]}。节点：树形结构的基本单元，包含自身信息及子节点（若有）。展开/折叠：子节点的显示与隐藏切换，是树形菜单的核心交互。递归渲染：因数据层级不固定，
    
                    
    • 
                    
  • 精通Canvas：15款时钟特效代码实现指南
                        烟幕缭绕

                        
    本文还有配套的精品资源，点击获取简介：HTML5的Canvas是一个用于绘制矢量图形的API，通过JavaScript实现动态效果。本项目集合了15种不同的时钟特效代码，帮助开发者通过学习绘制圆形、线条、时间更新、旋转、颜色样式设置及动画效果等概念，深化对Canvas的理解和应用。项目中的CSS文件负责时钟的样式设定，而JS文件则包含实现各种特效的逻辑，通过不同的函数或类处理时间更新和动画绘制，提
    
                    
    • 
                    
  • 深入剖析OpenJDK 18 GA源码：Java平台最新发展
                        想法臃肿

                        
    本文还有配套的精品资源，点击获取简介：OpenJDK18GA作为Java开发的关键里程碑，提供了诸多新特性和改进。本文章深入探讨了OpenJDK18GA源码，揭示其内部机制，帮助开发者更好地理解和利用这个版本。文章还涵盖了PatternMatching、SealedClasses、Records、JEP395、JEP406和JEP407等特性，以及HotSpot虚拟机、编译器、垃圾收集器、内存模型
    
                    
    • 
                    
  • Java大厂面试实录：谢飞机的电商场景技术问答（Spring Cloud、MyBatis、Redis、Kafka、AI等）
                        

                        
    Java大厂面试实录：谢飞机的电商场景技术问答（SpringCloud、MyBatis、Redis、Kafka、AI等）本文模拟知名互联网大厂Java后端岗位面试流程，以电商业务为主线，由严肃面试官与“水货”程序员谢飞机展开有趣的对话，涵盖SpringCloud、MyBatis、Redis、Kafka、SpringSecurity、AI等热门技术栈，并附详细解析，助力求职者备战大厂面试。故事设定谢
    
                    
    • 
                    
  • 【超硬核】JVM源码解读：Java方法main在虚拟机上解释执行
                        HeapDump性能社区
java开发语言后端jvm
                        
    本文由HeapDump性能社区首席讲师鸠摩（马智）授权整理发布第1篇-关于Java虚拟机HotSpot，开篇说的简单点开讲Java运行时，这一篇讲一些简单的内容。我们写的主类中的main()方法是如何被Java虚拟机调用到的？在Java类中的一些方法会被由C/C++编写的HotSpot虚拟机的C/C++函数调用，不过由于Java方法与C/C++函数的调用约定不同，所以并不能直接调用，需要JavaC
    
                    
    • 
                    
  • 算法学习笔记：17.蒙特卡洛算法 ——从原理到实战，涵盖 LeetCode 与考研 408 例题
                        

                        
    在计算机科学和数学领域，蒙特卡洛算法（MonteCarloAlgorithm）以其独特的随机抽样思想，成为解决复杂问题的有力工具。从圆周率的计算到金融风险评估，从物理模拟到人工智能，蒙特卡洛算法都发挥着不可替代的作用。本文将深入剖析蒙特卡洛算法的思想、解题思路，结合实际应用场景与Java代码实现，并融入考研408的相关考点，穿插图片辅助理解，帮助你全面掌握这一重要算法。蒙特卡洛算法的基本概念蒙特卡
    
                    
    • 
                    
  • Java大厂面试故事：谢飞机的互联网音视频场景技术面试全纪录（Spring Boot、MyBatis、Kafka、Redis、AI等）
                        来旺
Java场景面试宝典JavaSpringBootMyBatisKafkaRedis微服务AI
                        
    Java大厂面试故事：谢飞机的互联网音视频场景技术面试全纪录（SpringBoot、MyBatis、Kafka、Redis、AI等）互联网大厂技术面试不仅考察技术深度，更注重业务场景与系统设计能力。本篇以严肃面试官与“水货”程序员谢飞机的对话，带你体验音视频业务场景下的Java面试全过程，涵盖主流技术栈，并附详细答案解析，助你面试无忧。故事场景设定谢飞机是一名有趣但技术基础略显薄弱的程序员，这次应
    
                    
    • 
                    
  • 【前端】jQuery数组合并去重方法总结
                        

                        
    在jQuery中合并多个数组并去重，推荐使用原生JavaScript的Set对象（高效简单）或$.unique()（仅适用于DOM元素，不适用于普通数组）。以下是完整解决方案：方法1：使用ES6Set（推荐）//定义多个数组constarr1=[1,2,3];constarr2=[2,3,4];constarr3=[3,4,5];//合并数组并用Set去重constmergedArray=[...
    
                    
    • 
                    
  • MySQL Explain 详解：从入门到精通，让你的 SQL 飞起来
                        

                        
    引言：为什么Explain是SQL优化的“照妖镜”？在Java开发中，我们常常会遇到数据库性能瓶颈的问题。一条看似简单的SQL语句，在数据量增长到一定规模后，可能会从毫秒级响应变成秒级甚至分钟级响应，直接拖慢整个应用的性能。此时，你是否曾困惑于：为什么这条SQL突然变慢了？索引明明建了，为什么没生效？到底是哪里出了问题？答案就藏在MySQL的EXPLAIN命令里。EXPLAIN就像一面“照妖镜”，
    
                    
    • 
                    
  • Java特性之设计模式【责任链模式】
                        Naijia_OvO
Java特性java设计模式责任链模式
                        
    一、责任链模式概述顾名思义，责任链模式（ChainofResponsibilityPattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推主要解决：职责链上的处理者负责处理请求，客户只需要将
    
                    
    • 
                    
  • 日历插件-FullCalendar的详细使用
                        老马聊技术
JavaScript前端javascript
                        
    一、介绍FullCalendar是一个功能强大、高度可定制的JavaScript日历组件，用于在网页中显示和管理日历事件。它支持多种视图（月、周、日等），可以轻松集成各种框架，并提供丰富的事件处理功能。二、实操案例具体代码如下：FullCalendar日期选择body{font-family:Arial,sans-serif;margin:20px;}#calendar{max-width:900
    
                    
    • 
                    
  • react-native android 环境搭建
                        

                        
    环境：macjava版本：Java11最重要：一定要一定要一定要react涉及到很多的依赖下载，gradle和react相关的，第一次安装环境时有外网环境会快速很多。安装nodejs安装react-nativenpminstallreact-native-clinpminstallreact-native创建一个新项目react-nativeinitfirstReact替换gradle下载源rep
    
                    
    • 
                    
  • Java 调用 HTTP 接口的 7 种方式：全网最全指南
                        

                        
    Java调用HTTP接口的7种方式：全网最全指南在开发过程中，调用HTTP接口是最常见的需求之一。本文将详细介绍Java中7种主流的调用HTTP接口的方式，包括每种工具的优缺点和完整代码实现。1.使用RestTemplateRestTemplate是Spring提供的同步HTTP客户端，适用于传统项目。尽管从Spring5开始被标记为过时，它仍然是许多开发者的首选。示例代码importorg.sp
    
                    
    • 
                    
  • Java三年经验程序员技术栈全景指南：从前端到架构，对标阿里美团全栈要求
                        可曾去过倒悬山
java前端架构
                        
    Java三年经验程序员技术栈全景指南：从前端到架构，对标阿里美团全栈要求三年经验是Java程序员的分水岭，技术栈深度决定你成为“业务码农”还是“架构师候选人”。本文整合阿里、美团、滴滴等大厂招聘要求，为你绘制可落地的进阶路线。一、Java核心：从语法糖到JVM底层三年经验与初级的核心差异在于系统级理解，大厂面试常考以下能力：JVM与性能调优内存模型（堆外内存、元空间）、GC算法（G1/ZGC适用场
    
                    
    • 
                    
  • javascript高级程序设计第3版——第12章 DOM2与DOM3
                        weixin_30687587
javascript数据结构与算法ViewUI
                        
    12章——DOM2与DOM3为了增强D0M1，DOM级规范定义了一些模块。DOM2核心：为不同的DOM类型引入了一些与XML命名空间有关的方法，还定义了以编程方式创建Document实例的方法；DOM2级样式：针对操作元素的样式而开发；其特性总结：1.每个元素都有一个关联的style对象，可用来确定和修改行内样式；2.要确定某个元素的计算样式，可使用getComgetComputedStyle（）
    
                    
    • 
                    
  • Java设计模式实战：高频场景解析与避坑指南
                        mckim_
笔记学习java设计模式
                        
    引言设计模式是软件开发的基石，但许多开发者面对23种模式时容易陷入“学完就忘”或“滥用模式”的困境。本文从工业级项目视角出发，精选10种高频设计模式，结合真实代码案例与主流框架应用，帮你建立模式思维，拒绝纸上谈兵。一、创建型模式：告别new的暴力美学1.工厂方法模式（FactoryMethod）核心痛点：对象创建逻辑散落各处，难以统一管理。场景案例：电商平台需要支持多种支付方式（支付宝、微信、银联
    
                    
    • 
                    
  • JavaScript 基础09：Web APIs——日期对象、DOM节点
                        梦想当全栈
JavaScriptjavascript前端开发语言
                        
    JavaScript基础09：WebAPIs——日期对象、DOM节点进一步学习DOM相关知识，实现可交互的网页特效能够插入、删除和替换元素节点。能够依据元素节点关系查找节点。一、日期对象掌握Date日期对象的使用，动态获取当前计算机的时间。ECMAScript中内置了获取系统时间的对象Date，使用Date时与之前学习的内置对象console和Math不同，它需要借助new关键字才能使用。1.实例
    
                    
    • 
                    
  • 《Java前端开发全栈指南：从Servlet到现代框架实战》
                        

                        
    前言在当今Web开发领域，Java依然是后端开发的主力语言，而随着前后端分离架构的普及，Java开发者也需要掌握前端技术栈。本文将全面介绍JavaWeb前端开发的核心技术，包括传统Servlet/JSP体系、现代前端框架集成方案，以及全栈开发的最佳实践。通过本文，您将了解如何构建现代化的JavaWeb应用前端界面。一、JavaWeb前端技术演进1.1传统技术栈Servlet：JavaWeb基础，处
    
                    
    • 
                    
  • javaSE面试题---语法基础、面向对象、常用类、集合、多线程、文件和IO
                        yang_xiao_wu_
java面试开发语言javasejava基础多线程文件和IO
                        
    目录语法基础1.jdkjrejvm区别2.基本数据类型3.引用数据类型4.自动类型转换、强制类型转换5.常见的运算符6.&和&&区别7.++--在前和在后的区别8.+=有什么作用9.switch..case中switch支持哪些数据类型10.break和continue区别11.while和dowhile区别12.如何生成一个取值范围在[min,max]之间的随机数13.数组的长度如何获取？数组下
    
                    
    • 
                    
  • JAVA 高频八股文 Day03
                        Conqueror675
java开发语言
                        
    12.TCP和Http的区别是什么TCP是传输层协议，负责建立可靠的点对点连接，确保数据有序、完整地传输（如铁路轨道）；HTTP是应用层协议，基于TCP构建，定义了Web服务交互的报文格式和规则（如货运订单）。TCP关注数据如何可靠送达，通过三次握手建立连接、流量控制等机制保证传输；HTTP关注传输内容的意义，提供请求/响应语义（GET/POST等）和无状态通信。补充：说一下什么是三次握手四次挥手
    
                    
    • 
                    
  • JVM字节码加载与存储中的细节
                        

                        
    问题引出：为什么Java定义int型变量为32767时使用的是bipush32767，而定义int型变量为32768时使用的是ldc#4？在Java中，如果这样定义int型变量：publicclassTest{publicstaticvoidmain(String[]args){inti=0;intj=5;intk=6;intm=32768;intn=32767;}}变量对应的字节码文件内容是这样
    
                    
    • 
                    
  • JVM与Spring Boot核心解析
                        AIHacksCash
Java场景面试宝典JavaJVMSpringBoot
                        
    我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）清华大学出版社签约作家、Java领域优质创作者、CSDN博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、Spri
    
                    
    • 
                    
  • HashMap的Get(),Put()源码解析
                        Ttang23
哈希算法散列表算法
                        
    1、什么是HashMap？HashMap是Java中用于存储键值对（Key-Value）的集合类，它实现了Map接口。其核心特点是：无序性：不保证元素的存储顺序，也不保证顺序恒定不变。唯一性：键（Key）不能重复，若插入重复键会覆盖原有值。允许null：允许一个null键和任意数量的null值。非线程安全：相比HashTable，HashMap不支持同步，性能更高。2.核心数据结构：哈希表（Has
    
                    
    • 
                    
  • Java中的Tomcat，开启Web应用腾飞【基础版】
                        

                        
    目录一、Tomcat初登场：揭开神秘面纱（一）啥是Tomcat（二）为啥要有Tomcat二、Tomcat的安装与启动：开启第一步（一）下载Tomcat（二）启动Tomcat三、Tomcat的目录结构：探秘内部布局（一）核心目录介绍（二）目录间的协同工作四、部署JavaWeb应用到Tomcat：让应用上线（一）打包Web应用为WAR文件（二）部署WAR文件到Tomcat五、Tomcat的配置优化：让
    
                    
    • 
                    
  • Java Web 之 Session 详解
                        艾伦~耶格尔
java开发语言后端前端session
                        
    在JavaWeb开发中，Session就像网站的专属记忆管家，为每个用户保管着重要的信息和状态，确保用户在网站的旅程顺畅无阻。场景一：想象你去一家大型超市购物，推着购物车挑选商品。这个购物车就如同Session，它记录了你的购物信息，方便你在结账时一次性结算。场景二：你在玩一个在线游戏，登录账号后，你的游戏进度、等级、装备等信息都会被保存在Session中，即使你中途关闭游戏，下次登录时依然可以继
    
                    
    • 
                    
  • JavaScript之DOM操作与事件处理详解
                        AA-代码批发V哥
JavaScriptjavascript
                        
    JavaScript之DOM操作与事件处理详解一、DOM基础：理解文档对象模型二、DOM元素的获取与访问2.1基础获取方法2.2集合的区别与注意事项三、DOM元素的创建与修改3.1创建与插入元素3.2修改元素属性与样式3.2.1属性操作3.2.2样式操作3.3元素内容的修改四、DOM元素的删除与替换4.1删除元素4.2替换元素五、事件处理：实现页面交互5.1事件绑定的三种方式5.1.1HTML属性
    
                    
    • 
                    
  • V少JS基础班之第五弹
                        V少在逆向
JS基础班javascript开发语言ecmascript
                        
    文章目录一、前言二、本节涉及知识点三、重点内容1-函数的定义2-函数的构成1.函数参数详解1）参数个数不固定2）默认参数3）arguments对象（类数组）4）剩余参数（Rest参数）5）函数参数是按值传递的6）解构参数传递7）参数校验技巧（JavaScript没有类型限制，需要手动校验）2.函数返回值详解3-函数的分类1-函数声明式：2-函数表达式：3-箭头函数：4-构造函数：5-IIFE：6-
    
                    
    • 
                    
  • Javaweb学习之Vue模板语法（三）
                        不要数手指啦
vue.js学习前端
                        
    目录学习资料前情回顾本期介绍（vue模板语法）文本插值Vue的Attribute绑定使用JavaScript表达式综合实例代码：学习资料Vue.js-渐进式JavaScript框架|Vue.js(vuejs.org)前情回顾项目的创建大家可以看这篇文章Vue学习之项目的创建-CSDN博客本期介绍（vue模板语法）首先，找到我们编写代码的地方找到自己项目的src文件夹，打开之后点击component
    
                    
    • 
                    
  • Tomcat：Java Web应用的幕后英雄
                        互联网动态分析
tomcat
                        
    在当今数字化浪潮中，Java作为一门成熟且广泛应用的编程语言，支撑着无数企业级应用和互联网服务的稳定运行。而在JavaWeb开发领域，Tomcat无疑是一个举足轻重的存在，它宛如一位默默耕耘的幕后英雄，为众多Web应用提供了可靠的运行环境。Tomcat的起源与发展Tomcat的故事始于1999年，当时SunMicrosystems（后被Oracle收购）与Apache软件基金会合作，旨在为Java
    
                    
    • 
                                
  • 枚举的构造函数中抛出异常会怎样
                                    bylijinnan
javaenum单例
                                    
    首先从使用enum实现单例说起。 
 
为什么要用enum来实现单例？ 
这篇文章（ 
http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 
1.enum单例简单、容易，只需几行代码： 
 

public enum Singleton {
	INSTANCE;
    
                                
    • 
                                
  • CMake 教程
                                    aigo
C++
                                    
    转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/ 
  
CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。 
介绍：http://baike.baidu.com/view/1126160.htm 
本文件不介绍CMake的基本语法，下面是篇不错的入门教程： 
http:
    
                                
    • 
                                
  • cvc-complex-type.2.3: Element 'beans' cannot have character
                                    Cb123456
springWebgis
                                    
      cvc-complex-type.2.3: Element 'beans' cannot have character 
    Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
    
                                
    • 
                                
  • jquery实例:随页面滚动条滚动而自动加载内容
                                    120153216
jquery
                                    
    <script language="javascript">
$(function (){
	var i = 4;$(window).bind("scroll", function (event){
		//滚动条到网页头部的 高度，兼容ie,ff,chrome
		var top = document.documentElement.s
    
                                
    • 
                                
  • 将数据库中的数据转换成dbs文件
                                    何必如此
sqldbs
                                    
    旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 
1)数据库生成表结构信息： 
        主要生成数据库配置文件(.conf文
    
                                
    • 
                                
  • 在IBATIS中配置SQL语句的IN方式
                                    357029540
ibatis
                                    
    在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 
 
1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： 
 
 
 
<select id="getForms" param
    
                                
    • 
                                
  • Spring3 MVC 笔记（一）
                                    7454103
springmvcbeanRESTJSF
                                    
        
     自从 MVC 这个概念提出来之后 struts1.X  struts2.X   jsf 。。。。。 
这个view 层的技术一个接一个！ 都用过！不敢说哪个绝对的强悍！ 
要看业务，和整体的设计！ 
 
     最近公司要求开发个新系统！
    
                                
    • 
                                
  • Timer与Spring Quartz 定时执行程序
                                    darkranger
springbean工作quartz
                                    
    有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date; 
    
                                
    • 
                                
  • 大端小端转换，le32_to_cpu 和cpu_to_le32
                                    aijuans
C语言相关
                                    
    大端小端转换，le32_to_cpu 和cpu_to_le32   字节序  
http://oss.org.cn/kernel-book/ldd3/ch11s04.html 
        小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
    
                                
    • 
                                
  • Nginx负载均衡配置实例详解
                                    avords

                                    
    [导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解  负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。 
负载均衡 
先来简单了解一下什么是负载均衡
    
                                
    • 
                                
  • 乱说的
                                    houxinyou
框架敏捷开发软件测试
                                    
    从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！   
这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白.    
不过感觉和程序开发语言差不多，   
瀑布就是顺序，敏捷就是循环.    
瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。   
  
也可以把软件开发理
    
                                
    • 
                                
  • 欣赏的价值——一个小故事
                                    bijian1013
有效辅导欣赏欣赏的价值
                                    
    　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
    
                                
    • 
                                
  • 包冲突问题的解决方法
                                    bingyingao
eclipsemavenexclusions包冲突
                                    
    包冲突是开发过程中很常见的问题： 
其表现有： 
1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 
2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 
3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就 
抛如下异常： 
 
java.lang.NoClassDefFoundError: Could not in
    
                                
    • 
                                
  • 【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j
                                    bit1129
Stream
                                    
    先来一段废话： 
实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
    
                                
    • 
                                
  • sudoku solver in Haskell
                                    bookjovi
sudokuhaskell
                                    
    这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。 
  
现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
    
                                
    • 
                                
  • java apache ftpClient
                                    bro_feng
java
                                    
    最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 
1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。 
 
看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-工厂方法模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 


package design.pattern;

/*
 * 工厂方法模式：使一个类的实例化延迟到子类
 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）：
 * 有很多不同的产品，它
    
                                
    • 
                                
  • 面试记录语
                                    chenyu19891124
招聘
                                    
    或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。 
今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
    
                                
    • 
                                
  • Fire Workflow 1.0正式版终于发布了
                                    comsci
工作workflowGoogle
                                    
    Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 
 官方网站是 http://www.fireflow.org 
 
 经过大家努力,Fire Workflow 1.0正式版终于发布了 
 
 正式版主要变化: 
1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 
2、增加IT
    
                                
    • 
                                
  • Python向脚本传参
                                    daizj
python脚本传参
                                    
    如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？ 
需要模块：sys 
参数个数：len(sys.argv) 
脚本名：    sys.argv[0] 
参数1：     sys.argv[1] 
参数2：     sys.argv[
    
                                
    • 
                                
  • 管理用户分组的命令gpasswd
                                    dongwei_6688
passwd
                                    
    NAME：  gpasswd - administer the /etc/group file 
SYNOPSIS： 
 gpasswd group 
 gpasswd -a user group 
 gpasswd -d user group 
 gpasswd -R group 
 gpasswd -r group 
 gpasswd [-A user,...] [-M user,...] g
    
                                
    • 
                                
  • 郝斌老师数据结构课程笔记
                                    dcj3sjt126com
数据结构与算法
                                    
    <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    
                                
    • 
                                
  • yii2 cgridview加上选择框进行操作
                                    dcj3sjt126com
GridView
                                    
    页面代码
<?=Html::beginForm(['controller/bulk'],'post');?>
<?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
    
                                
    • 
                                
  • linux mysql
                                    fypop
linux
                                    
    enquiry mysql version in centos linux 
yum list installed | grep mysql 
yum -y remove mysql-libs.x86_64 
enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* 
install mysq
    
                                
    • 
                                
  • Scramble String
                                    hcx2013
String
                                    
    Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. 
Below is one possible representation of s1 = "great":
    
                                
    • 
                                
  • 跟我学Shiro目录贴
                                    jinnianshilongnian
跟我学shiro
                                    
    历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。 
  
  
----广告-----------------------------------------------------
    
                                
    • 
                                
  • nginx日志切割并使用flume-ng收集日志
                                    liyonghui160com

                                    
      
   nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
    
                                
    • 
                                
  • Oracle死锁解决方法
                                    pda158
oracle
                                    
    　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
    
                                
    • 
                                
  • java之List排序
                                    shiguanghui
list排序
                                    
       在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。 　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
    
                                
    • 
                                
  • servlet单例多线程
                                    utopialxw
单例多线程servlet
                                    
    转自http://www.cnblogs.com/yjhrem/articles/3160864.html 
和   http://blog.chinaunix.net/uid-7374279-id-3687149.html 
Servlet 单例多线程 
Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的
    
                                
    •