首页 > 编程语言 >八期day06-java基础2

八期day06-java基础2

时间：2023-07-02 16:33:16浏览次数：49  
标签：java System day06 add names println 八期 public out

零 python和java字节字符串比较

0.1 java字节数组和字符串相互转换

//1  字符串转字节数组
v4 = "彭于晏"
byte[] b = v4.getBytes(); // 默认utf8形式
System.out.println(b); // 输出对象形式，看不到字节数组
System.out.println(Arrays.toString(b));


//        try {
//            byte[] b1 = v4.getBytes("GBK"); // 'GBK'形式，需要捕获异常
//        } catch (Exception e) {
//
//        }
byte[] b1 = v4.getBytes("GBK"); // 'GBK'形式，需要捕获异常,或在方法上  throws Exception
System.out.println(Arrays.toString(b1));


// 2 字节数组转字符串
String v8 = new String(new byte[]{-27, -67, -83, -28, -70, -114, -26, -103, -113});
String v9 = new String(new byte[]{-59, -19, -45, -38, -22, -52},"GBK");
System.out.println(v8);
System.out.println(v9);

0.2 java 字符数组和字符串相互转换

// 1 字符数组转字符串
  char[] c=new char[]{'彭','于','晏'};
  String v1 = new String(c);
  System.out.println(v1);

// 2 字符串串转字符数组
  String str1 = "彭于晏";
  char[] c=str1.toCharArray();
  System.out.println(c.length);
  System.out.println(c[0]);

0.3 python字节和字符串

##### python中字符串与字节
v1 = '彭于晏'
v2 = v1.encode('utf-8')
print(v2)  # b'\xe5\xbd\xad\xe4\xba\x8e\xe6\x99\x8f'   16进制表示
v3 = v1.encode('GBK')
print(v3)  # b'\xc5\xed\xd3\xda\xea\xcc'  16进制表示

# 转换为10进制
v3 = [item for item in v2]
print(v3)  # [229, 189, 173, 228, 186, 142, 230, 153, 143]

# 转换为二进制
v4 = [bin(item) for item in v2]
print(v4)  # ['0b11100101', '0b10111101', '0b10101101', '0b11100100', '0b10111010', '0b10001110', '0b11100110', '0b10011001', '0b10001111']

# 转换为16进制
v5 = [hex(item) for item in v2]
print(v5) # ['0xe5', '0xbd', '0xad', '0xe4', '0xba', '0x8e', '0xe6', '0x99', '0x8f']

0.4 java字节数组转python字符串

# 字节有无符号
   Python字节无符号（不含负数）： 0 ~ 255
       0 1 2 3 4 5 ... 127  128  129  130 ... 255

   Java字节是有符号（含有负数）：-128 ~ 127
       0 1 2  3 4 5 ...127  -128 -127 - 126 -125 .... -2  -1
    
# python:彭于晏
[229, 189, 173, 228, 186, 142, 230, 153, 143]
# java：彭于晏
[-27, -67, -83, -28, -70, -114, -26, -103, -113]


### 编写一个java字节数组转换为python的字符串代码
	逻辑是：数字大于0，不操作，小于0，加上256

v1 = [-27, -67, -83, -28, -70, -114, -26, -103, -113]
def java_arr_to_python_str(v1):
    num_list = bytearray()
    for i in v1:
        if i < 0:
            i = i + 256
        num_list.append(i)
    return num_list.decode('utf-8')


if __name__ == '__main__':
    print(java_arr_to_python_str(v1))

一 Object类

Object类是java.lang包下的核心类，Object类是所有类的父类，何一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类

以下两种类的定义的最终效果是完全相同的

class Person { }

class Person extends Object { }

1.1 Object类可以接受所有类的对象

public class Demo05 {
    public static void main(String[] args) {
        String name="justin";
        int age =19;
        Object v1=name;
        v1=age;
        Person p=new Person();
        v1=p;
        System.out.println(v1);
        // 定义Object类型数组
        Object[] arrs=new Object[3];
        arrs[0]="justin";
        arrs[1]=19;
        arrs[2]=p;
        System.out.println(Arrays.toString(arrs));

    }
}

class Person{
}

1.2 Object 类的方法

Object 类属于java.lang包，此包下的所有类在使用时无需手动导入，系统会在程序编译期间自动导入

image-20230629134852387

// 1. clone()
保护方法，实现对象的浅复制，只有实现了Cloneable接口才可以调用该方法，否则抛出CloneNotSupportedException异常。

// 2. getClass()
final方法，返回Class类型的对象，反射来获取对象。

//3. toString()
该方法用得比较多，一般子类都有覆盖，来获取对象的信息。

//4. finalize()
该方法用于释放资源。因为无法确定该方法什么时候被调用，很少使用。

//5. equals()
比较对象的内容是否相等

// 6. hashCode()
该方法用于哈希查找，重写了equals方法一般都要重写hashCode方法。这个方法在一些具有哈希功能的Collection中用到。

// 7. wait()
wait方法就是使当前线程等待该对象的锁，当前线程必须是该对象的拥有者，也就是具有该对象的锁。wait()方法一直等待，直到获得锁或者被中断。wait(long timeout)设定一个超时间隔，如果在规定时间内没有获得锁就返回。
调用该方法后当前线程进入睡眠状态，直到以下事件发生。
其他线程调用了该对象的notify方法。
其他线程调用了该对象的notifyAll方法。
其他线程调用了interrupt中断该线程。
时间间隔到了。
此时该线程就可以被调度了，如果是被中断的话就抛出一个InterruptedException异常。

// 8. notify()
该方法唤醒在该对象上等待的某个线程。

//9. notifyAll()
该方法唤醒在该对象上等待的所有线程。

    
/* 常用的
    getClass()
    toString()
    hashCode()
*/

1.3 获取Object类型变量的具体类型

       // 4 把Object转回具体类型
        // 4.1 方式一
        Person p = new Person();
        Object[] names = new Object[]{"彭于晏", "刘亦菲", 19, p};
        System.out.println(names[0].getClass());   // 返回具体的类型  class java.lang.String
        System.out.println(names[3].getClass());   // 返回具体的类型  class Person

        // 方式2   通过判断转换
        if (names[0] instanceof String) {
            String v1 = (String) names[0];
            System.out.println(v1);
        }
        if (names[2] instanceof Integer) {
            Integer a1 = (Integer) names[2];
            System.out.println(a1);
        }
        if (names[3] instanceof Person) {
            Person p1 = (Person) names[3];
            System.out.println(p1);
        }

二 容器类型之List

List是一个接口，接口下面有两个常见的类型（目的是可以存放动态的多个数据）

Java的数组只能放取，不能扩容缩容，增加删除元素

  • ArrayList，连续的内存地址的存储（底层基于数组，内部自动扩容） -> Python列表的特点
  • LinkedList，底层基于链表实现（底层基于链表） -> Python列表的特点
  • 后面讲的ArrayList和LinkedList所有方法都一样，但是他们操作数据效率不一样

2.1 基本使用

import java.util.ArrayList;  // 需要导入使用，编辑器会自动导入
import java.util.LinkedList;

public class Demo04 {
    public static void main(String[] args) {
        // List 接口类型：ArrayList和LinkedList

        // 1 ArrayList
////        ArrayList l1 = new ArrayList();  // 定义ArrayList -->如果这样写，表示内部放的是Object类型
//        ArrayList<Object> l1 = new ArrayList<Object>();  //上面等同于
//        // 放入元素
//        l1.add("彭于晏");
//        l1.add("Justin");
//        l1.add("留一份");
//        l1.add(99); // 可以放任意类型
//        l1.add(new Dog());
//        System.out.println(l1);
//
//        ArrayList<String> l2 = new ArrayList<String>();
////        l2.add(99);  // 只能放字符串类型
//        l2.add("xxxx");
////        l2.add('中');  // 字符类型也不可以


        // 2 LinkedList

//        LinkedList l1 = new LinkedList();  // 定义LinkedList-->如果这样写，表示内部放的是Object类型
        LinkedList<Object> l1 = new LinkedList<Object>();  //上面等同于
        // 放入元素
        l1.add("彭于晏");
        l1.add("Justin");
        l1.add("留一份");
        l1.add(99); // 可以放任意类型
        l1.add(new Dog());
        System.out.println(l1);

//        LinkedList<String> l2=new LinkedList();
//        LinkedList<String> l2=new LinkedList<>();
        LinkedList<String> l2 = new LinkedList<String>();
        l2.add("justin");
        l2.add(11);  //不行


    }
}

class Dog {
}

2.2 接口概念(了解)

image-20230702155736322


// 接口用来规范子类行为：java不允许多继承，实现多个接口，接口是就一个规范，规定了子类有那些方法，但是没有具体实现

// python 中不需要显示的继承一个类，只要类中有共同的属性或方法，他们就属于同一类


/**
 * 定义了一个接口，规定，有两个方法，speak，run，我的子类，必须实现这俩方法
 */
interface Duck {
    public void speak();

    public void run();
}


class TDuck implements Duck {
    public void speak() {
        System.out.println("唐老鸭说话");
    }

    public void run() {
        System.out.println("唐老鸭走路");
    }

}

class PDuck implements Duck {
    public void speak() {
        System.out.println("普通鸭说话");
    }

    public void run() {

    }

    public void eat(){}

}


public class Demo05 {
    public static void main(String[] args) {
        //接口的概念
        TDuck t = new TDuck();
        PDuck p = new PDuck();
        // 接口类型的变量，可以接收 实现
        Duck d = t;
        d = p;
    }
}

2.3 指定类型的List及常用操作

import java.util.ArrayList;
import java.util.LinkedList;


public class Demo05 {
    public static void main(String[] args) {

        //***************** ArrayList 常用操作
//        ArrayList<String> names = new ArrayList<String>();
//        names.add("彭于晏");
//        names.add("古天乐");
//        names.add("杨颖");
////        names.add(19);  //不能放数字
//        names.add("刘亦菲");
//        //1  根据索引取值
//        String name = names.get(1);
//        System.out.println(name);
//
//        // 2 修改某个位置值
//        names.set(1,"迪丽热巴");
//        System.out.println(names);
//
//        // 3 删除某个值
//        names.remove("迪丽热巴");
//        names.remove(0);
//
//        // 4 大小
//        System.out.println(names.size());
//        // 5 是否包含
//        System.out.println(names.contains("刘亦菲"));
//
//        // 6 循环
//        for (int i = 0; i < names.size(); i++) {
//            System.out.println(names.get(i));
//        }
//
//        for (String item:names) {
//            System.out.println(item);
//
//        }


        //***************** ArrayList 常用操作
        LinkedList<String> names = new LinkedList<String>();
        names.add("彭于晏");
        names.add("古天乐");
        names.add("杨颖");
//        names.add(19);  //不能放数字
        names.add("刘亦菲");
        //1  根据索引取值
        String name = names.get(1);
        System.out.println(name);

        // 2 修改某个位置值
        names.set(1,"迪丽热巴");
        System.out.println(names);

        // 3 删除某个值
        names.remove("迪丽热巴");
        names.remove(0);

        // 4 大小
        System.out.println(names.size());
        // 5 是否包含
        System.out.println(names.contains("刘亦菲"));

        // 6 循环
        for (int i = 0; i < names.size(); i++) {
            System.out.println(names.get(i));
        }

        for (String item:names) {
            System.out.println(item);

        }

        // 7  其他操作
        names.push("xxx"); // 放在首位

        names.addFirst("第一");
        names.addLast("倒数第一");
        System.out.println(names);
    }
}

2.4 迭代

// 类似于python的迭代器

//ArrayList<String> names = new ArrayList<String>();
LinkedList<String> names = new LinkedList<String>();
names.add("彭于晏");
names.add("古天乐");
names.add("杨颖");
names.add("刘亦菲");
Iterator i =names.iterator();
while (i.hasNext()){
    System.out.println(i.next());
}

三 容器类型之 Set

Set是一个接口，常见实现这个接口的有两个类，用于实现不重复的多元素集合。

  • HashSet，去重，无序。
  • TreeSet，去重，内部默认排序（ascii、unicode）【不同的数据类型，无法进行比较】。

3.1 基本使用

import java.util.Arrays;
import java.util.HashSet;
import java.util.TreeSet;

public class Demo04 {
    public static void main(String[] args) throws Exception {

        // HashSet使用
//        HashSet h= new HashSet();
//        HashSet<String> h= new HashSet<String>();
//        // 1 基本使用
//        h.add("刘亦菲");
//        h.add("刘亦菲");
//        h.add("迪丽热巴");
//        h.add("古天乐");
//        h.add("彭于晏");
//        h.add("Justin");
//
//        System.out.println(h);
//
//        // 2 判断值是否存在
//        System.out.println(h.contains("迪丽热巴"));
//
//        // 3 删除元素
//        h.remove("刘亦菲");
//        System.out.println(h);
//        // 4 长度
//        System.out.println(h.size());


        // TreeSet使用，自动排序
        TreeSet<String> h = new TreeSet<String>();
//        TreeSet<String> h = new TreeSet<String>(){{add("刘亦菲");add("迪丽热巴");}};

        // 1 基本使用
        h.add("刘亦菲");
        h.add("刘亦菲");
        h.add("迪丽热巴");
        h.add("古天乐");
        h.add("彭于晏");
        h.add("Justin");

        System.out.println(h);

        // 2 判断值是否存在
        System.out.println(h.contains("迪丽热巴"));

        // 3 删除元素
        h.remove("刘亦菲");
        System.out.println(h);
        // 4 长度
        System.out.println(h.size());


    }
}

3.2 交并差集

import java.util.Arrays;
import java.util.HashSet;
import java.util.TreeSet;

public class Demo04 {
    public static void main(String[] args) throws Exception {
        HashSet<String> h1 = new HashSet<String>();
        h1.add("古天乐");
        h1.add("彭于晏");
        h1.add("Justin");

        HashSet<String> h2 = new HashSet<String>();
        h2.add("古力娜扎");
        h2.add("杨颖");
        h2.add("迪丽热巴");
        h2.add("刘亦菲");
        h2.add("Justin");

        HashSet<String> h3 = new HashSet<String>();
        h3.addAll(h2);     // 把h2的所有数据增加到h3中

        System.out.println(h3);

        h3.retainAll(h1);  // 交集 &  [Justin]
        System.out.println(h3);

        h2.addAll(h1);     // 并集 |    [杨颖, 迪丽热巴, 古力娜扎, 刘亦菲, Justin, 古天乐, 彭于晏]
        System.out.println(h2);


        h2.removeAll(h1);   // 差集      [杨颖, 迪丽热巴, 古力娜扎, 刘亦菲]
        System.out.println(h2);




    }
}

3.3 循环取值和迭代

import java.util.HashSet;
import java.util.Iterator;

public class Demo04 {
    public static void main(String[] args) throws Exception {
        HashSet<String> h1 = new HashSet<String>();
        h1.add("古天乐");
        h1.add("彭于晏");
        h1.add("Justin");

        // 循环
        for (String item: h1) {
            System.out.println(item);
        }
        //迭代
        Iterator i=h1.iterator();
        while (i.hasNext()){
            System.out.println(i.next());
        }
    }
}

四 容器类型之Map

Map是一个接口，常见实现这个接口的有两个类，用于存储键值对。

  • HashMap，无序。

  • TreeMap，默认根据key排序。（常用）

4.1 基本使用

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeMap;

public class Demo04 {
    public static void main(String[] args) throws Exception {
//        HashMap hm=new HashMap();
//        hm.put("name","lqz");
//        hm.put("age",19);
//        hm.put("hobby","篮球");
//        System.out.println(hm);

//        HashMap<String,String> hm=new HashMap<String,String> ();
//        hm.put("name","lqz");
//        hm.put("age","19");
//        hm.put("hobby","篮球");
//        System.out.println(hm);


        TreeMap<String,String> hm=new TreeMap<String,String> ();
        hm.put("name","lqz");
        hm.put("age","19");
        hm.put("hobby","篮球");
        System.out.println(hm);
        
    }
}

4.2 常用操作

import java.util.*;

public class Demo04 {
    public static void main(String[] args) throws Exception {
        TreeMap<String,String> hm=new TreeMap<String,String> ();
        hm.put("name","lqz");
        hm.put("age","19");
        hm.put("hobby","篮球");
        System.out.println(hm);

        // 1 移除元素
        hm.remove("name");
        System.out.println(hm);
        // 2 大小
        System.out.println(hm.size());

        // 3 获取值
        System.out.println(hm.get("name"));

        //4 包含
        System.out.println(hm.containsKey("name"));
        System.out.println(hm.containsValue("篮球"));

        //5 替换
        hm.replace("age","99");
        System.out.println(hm);

        //6 循环 方式一   keySet
        for (String key:hm.keySet()) {
            System.out.println(hm.get(key));
        }

        // 循环方式 二   entrySet
        for (Map.Entry<String,String> item:hm.entrySet()) {
            System.out.println(item);
            System.out.println(item.getKey());
            System.out.println(item.getValue());

        }

        // 循环方式 三
        Set s2 = hm.entrySet();
        Iterator it2 = s2.iterator();
        while (it2.hasNext()) {
            Map.Entry entry = (Map.Entry) it2.next();
            String k = (String) entry.getKey();
            String v =  (String) entry.getValue();
            System.out.println(k);
            System.out.println(v);
        }


    }
}

五 面向对象

5.1 类与对象构造方法

public class Demo09 {
    public static void main(String[] args) {
        //1  类实例化得到对象
//        Animal a =new Animal();  //
//        a.speak();

        // 2 python中有__init__  构造方法   有参和无参构造方法
//        Animal a = new Animal();  //触发无参构造
        Animal a1 = new Animal("Justin", 19);//触发有参构造
        System.out.println(a1.name);
        System.out.println(a1.age);

    }
}

/**
 * 定义类
 */
class Animal {

    public String name;
    public int age;

    /**
     * 构造方法，无参构造，构造方法可以写多个
     */
    public Animal() {
        System.out.println("我是无参");
    }

    /**
     * 有参构造方法
     *
     * @param name
     * @param age
     */
    public Animal(String name, int age) {
        System.out.println("我是有参");
        // java中this 代指 python的self
        this.name=name;
        this.age=age;


    }

    public void speak() {
        System.out.println("说话了");
    }


}

5.1.1 方法重载

import java.util.*;

public class Demo04 {
    public static void main(String[] args) throws Exception {

        Person p =new Person();
        System.out.println(p);

        Person p1=new Person("Justin",99);
        System.out.println(p1);


        p.speak();
        p.speak("说呀说");
    }
}

class Person {
    public String name;
    public int age;

    /**
     * 构造方法一
     */
    public Person() {
        this.name = "justin";
        this.age = 19;


    }

    /**
     * 构造方法2
     * @param name
     * @param age
     */
    public Person(String name, int age) {
        this.name = name;
        this.age = age;

    }

    /**
     * speak方法，无参数
     */
    public void speak(){
        System.out.println("说哈");
    }
    /**
     * speak方法，有参数，重载方法
     */
    public void speak(String s){
        System.out.println(s);
    }
}

5.1.2 Hook重载的方法

/*
adb shell
su
cd /data/local/tmp/
./frida-server-16.0.19-android-arm64 

端口转发
adb forward tcp:27042 tcp:27042
adb forward tcp:27043 tcp:27043
*/

import frida
import sys

# 连接手机设备
rdev = frida.get_remote_device()

session = rdev.attach("油联合伙人")

scr = """
Java.perform(function () {

    // 包.类
    var MessageDigest = Java.use("java.security.MessageDigest");

    MessageDigest.update.overload('[B').implementation = function(data){
        var res = this.update(data);
        return res;
    }
    
    MessageDigest.update.overload('java.nio.ByteBuffer').implementation = function(data){
        var res = this.update(data);
        return res;
    }

});
"""

script = session.create_script(scr)


def on_message(message, data):
    print(message, data)


script.on("message", on_message)

script.load()
sys.stdin.read()

5.1.3 Hook构造方法

import frida
import sys

# 连接手机设备
rdev = frida.get_remote_device()

session = rdev.attach("油联合伙人")

scr = """
Java.perform(function () {

    // 包.类
    var StringBuilder = Java.use("java.lang.StringBuilder");

    StringBuilder.$init.overload('int').implementation = function(num){
        console.log(num);
        if(num==32){
            var res = this.$init(num);
        }
        return res;
    }

});
"""

script = session.create_script(scr)


def on_message(message, data):
    print(message, data)


script.on("message", on_message)

script.load()
sys.stdin.read()

5.2 静态成员(方法，变量)

public class Demo10 {
    public static void main(String[] args) {
        Cat c =new Cat("小野猫",4);
        System.out.println(c.name); // 小野猫

        Cat c1 =new Cat("大野猫",40);
        System.out.println(c.name);  // 大野猫


        // python中有类属性，java的意思是用static修饰
        // 静态成员，类可以来调用，对象也可以调用
        c1.school="清华大学";
        System.out.println(c1.school);
        System.out.println(c.school);    //改了静态成员，所有对象都受影响
        // 通过类来改
        Cat.school="北京大学";
        System.out.println(c1.school);
        System.out.println(c.school);    //改了静态成员，所有对象都受影响


        // 类和对象都可以调用静态方法
        c1.speak();
        Cat.speak();

    }
}


class Cat{
    // 这些成员属于对象的
    public String name;
    public int age;
    // 静态成员，属于类的
    public static String school;
    public Cat(String name,int age){
        this.name=name;
        this.age=age;

    }

    public static void speak(){
        // 静态方法，python中的类方法，对象可以调用，类也可以调用
        System.out.println("猫喵喵叫");

    }

}

5.3 继承

Java中的继承，只支持单继承，不支持多继承，但支持实现多个接口

5.3.1 java只支持单继承

// java中只允许单继承

public class Demo11 {
    public static void main(String[] args) {

        Fish f=new Fish();
        f.eat();
        f.eat("xxxxxxx");

    }
}


class  Base extends Foo{
    public void eat(){
        System.out.println("吃吃吃");
    }

}

class Foo{

}

class Fish extends Base{
    @Override    // 子类中重写
    public void eat() {
        System.out.println("重写了eat方法");
    }

    public void eat(String a){// 重载
        // 方法可以同名，参数不一样，这个叫重载，跟父类没有必然联系
        System.out.println(a);

    }
}

// java只允许单继承 使用extends ，子类中重写父类的方法叫重写
// 方法名相同，但是参数不同，叫重载 ，跟父类没有必然联系

5.3.2 实现多个接口

interface Base{
    public void speak();

}
interface Foo{
    public void run();

}

class  Person implements Base,Foo{

    @Override
    public void speak() {
        
    }

    @Override
    public void run() {

    }
}

标签：java,System,day06,add,names,println,八期,public,out
From： https://www.cnblogs.com/fuminer/p/17520940.html

相关文章

  • java List复制：浅拷贝与深拷贝
    Java的拷贝可以分为三种：浅拷贝(ShallowCopy)、深拷贝(DeepCopy)、延迟拷贝(LazyCopy)。在java中除了基本数据类型之外（int,long,short等），还存在引用数据类型，例如String以及对象实例。对于基本数据类型，实际上是拷贝它的值，而对于引用数据类型，拷贝的就是它的引用，并没有创建一个新的......
  • java -- 常见API` 1
        ......
  • javac: invalid target release: 1.6
    Itriedtobuildaprojectonnetbeanswhenthiserrorcameup:javac:invalidtargetrelease:1.6Usage:javac<options><sourcefiles>wherepossibleoptionsinclude:-gGeneratealldebugginginfo-g:noneGeneratenodebugginginfo-......
  • 关于java 虚拟机栈
    线程的栈是在哪里提出来了的？Oracle官网的java虚拟机规范里面，2.5.2章节。网址：https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-2.html下图就是我们常说的java虚拟机栈。java虚拟机栈的栈帧具体是什么？栈帧（StackFrame）是以方法（Method）为基础的。栈帧里面有局部变量表(......
  • JAVA_OPTS
    JAVA_OPTS是一个环境变量，它可用于设置Java虚拟机（JVM）的运行参数。通过设置JAVA_OPTS环境变量，您可以为Java应用程序提供各种运行时配置。以下是使用JAVA_OPTS环境变量进行常见配置的示例：指定堆内存大小：-Xmx：设置最大堆内存大小，如 -Xmx2G 表示将最大堆内存设置为2GB......
  • 什么是JAVA内容仓库(Java Content Repository)
    内容仓库模型JSR-170是这样定义内容仓库的，内容仓库由一组workspace（工作空间）组成，这些workspace通常应该包含相似的内容。一个内容仓库有一个到多个workspace。每个workspace都是一个树状结构，都有一个唯一的树根节点（rootnode）。树上的item（元素）或者是个node（节点）或者是个property......
  • JSON中，java.lang.NoClassDefFoundError: net/sf/ezmorph/Morpher问题解决
    使用JSON，在SERVLET或者STRUTS的ACTION中取得数据时，如果会出现异常：java.lang.NoClassDefFoundError:net/sf/ezmorph/Morpher是因为需要的类没有找到，一般，是因为少导入了JAR包，使用JSON时，除了要导入JSON网站上面下载的json-lib-2.2-jdk15.jar包之外，还必须有其它几个依赖包：commons-bean......
  • 深入探究Java中的Map数据结构
    引言：在Java编程中，Map是一种重要的数据结构，它提供了键值对的存储和检索功能。在本篇博客文章中，我们将深入探究Java中的Map，包括不同实现类的比较，常见的用法和一些高级技巧。通过深入理解Map的内部机制和使用方法，你将能够更好地应用它解决实际问题。一、Map概述Map是Java中的一个接......
  • Java学习——数组
    数组一、数组的定义Java语言中提供的数组是用来存储固定大小的同类型元素。二、数组声明和创建1.声明数组变量首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：dataType[]arrayRefVar;//首选的方法或dataTypearrayRefVar[];//效果相同，......
  • Java主流jdk发行版有哪些?
    Java的特点是百花齐放，不像c#或者go只有一家主导。oraclejdk收费了，没关系，不是只有它可用。java还有很多免费的主流的jdk发行版，记录下来备忘。OpenJDK-官方网站-源代码-文档-下载地址OpenJDK是其他所有jdk发行版的基础，可以用于开发和测试，但不建议将它用于Java生产环......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99