Java编程思想_学习记录

章北海01

已于 2023-11-24 14:50:38 修改

阅读量41

点赞数

分类专栏： JavaSE 文章标签： java

于 2021-01-24 15:27:37 首次发布

本文链接：https://blog.csdn.net/qq_33274797/article/details/113029530

版权

JavaSE 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

学习代码1

@Slf4j
public class ObjectMappingUtil {

    public static <T> void setObject(T t, Map map) {
        Class cl = t.getClass();
        map.forEach((k, v) -> {
            try {
                String name = k.toString().substring(0, 1).toUpperCase() + k.toString().substring(1);
                Method mo = cl.getMethod("get" + name);
                //类型判断可扩展
                if (mo.getReturnType().getName().equals(Integer.class.getName())) {
                    mo = cl.getMethod("set" + name, Integer.class);
                    mo.invoke(t, v);
                } else if (mo.getReturnType().getName().equals(String.class.getName())) {
                    mo = cl.getMethod("set" + name, String.class);
                    mo.invoke(t, v);
                } else if (mo.getReturnType().getName().equals(Long.class.getName())) {
                    mo = cl.getMethod("set" + name, Long.class);
                    mo.invoke(t, v);
                } else if (mo.getReturnType().getName().equals(Double.class.getName())) {
                    mo = cl.getMethod("set" + name, Double.class);
                    mo.invoke(t, v);
                } else if (mo.getReturnType().getName().equals(Date.class.getName())) {
                    mo = cl.getMethod("set" + name, Date.class);
                    mo.invoke(t, v);
                } else if (mo.getReturnType().getName().equals(Float.class.getName())) {
                    mo = cl.getMethod("set" + name, Float.class);
                    mo.invoke(t, v);
                } else if (mo.getReturnType().getName().equals(Boolean.class.getName())) {
                    mo = cl.getMethod("set" + name, Boolean.class);
                    mo.invoke(t, v);
                }
            } catch (NoSuchMethodException e) {
                log.error("当前字段属性:" + k + ",不在类中");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        });
    }
}

java.lang默认导入到每个Java文件中，所以它的所有类都可以被使用。

-----------------------------------------------------------------
产生0和1之间(包括0,但不包括1)的一个double值。
double random = Math.random();

[main] INFO com.ldd.ApplicationRun - value=0.8721428965277569
[main] INFO com.ldd.ApplicationRun - value=0.7560859862349726
[main] INFO com.ldd.ApplicationRun - value=0.28874119595045744
[main] INFO com.ldd.ApplicationRun - value=0.3053520844446065
[main] INFO com.ldd.ApplicationRun - value=0.6709031215074425
[main] INFO com.ldd.ApplicationRun - value=0.9501723542358601

----------------------------------------------------------------
Character.isLowerCase()方法检测字符是否为小写字母。

char c = 66;
log.info(Character.isLowerCase(c) + "");
log.info(c + "");

[main] INFO com.ldd.ApplicationRun - false
[main] INFO com.ldd.ApplicationRun - B

-----------------------------------------------------------------
void方法中没有return语句，那么在该方法的结尾处会有一个隐式的return。
-----------------------------------------------------------------
goto是Java中的一个保留字，但在语言中并未使用它。

1.基本类型

基本数据类型，不用new创建。这个变量直接存储"值",并且存放在堆栈中(栈).

基本类型	大小	默认值	包装器类型
boolean	-	false	Boolean
char	16bits	'\u0000'(null)	Character
byte	8bits	(byte)0	Byte
short	16bits	(short)0	Short
int	32bits	0	Integer
long	64bits	0L	Long
float	32bits	0.0F	Float
double	64bits	0.0D	Double
void	-	-	Void

所有数值类型都有正符号。

2.类

类中基本类型字段，没有初始化，Java也会赋予一个初始默认值。
注意：当变量作为类的成员使用时，Java才确保给定其默认值。

package com.xl;

/**
 * @author 小李同学
 * @pageage com.xl
 * @date 2021/1/24 14:15
 * @week 星期日
 */
public class User {

    public int age;

    public boolean sex;

}


package com.xl;

/**
 * @author 小李同学
 * @pageage com.xl
 * @date 2021/1/24 14:16
 * @week 星期日
 */
public class Application {

    public static void main(String[] args) {
        User user = new User();
        System.out.println(user.sex); //false
        System.out.println(user.age); //0
    }
}

注意：当变量作为类的成员使用时，Java才确保给定其默认值。
public void outAge(){
	int i;
	
    //局部变量(非某个类的字段)时，使用时需要给定初始值。
    //i未给定值，编译错误
	System.out.println(i);
}

3.方法参数传递-基本类型

方法参数为基本类型时，是将外部变量值拷贝到局部变量中而进行逻辑处理的，故方法是不能修改原基本变量的。



package com.xl;

/**
 * @author 小李同学
 * @pageage com.xl
 * @date 2021/1/24 14:16
 * @week 星期日
 */
public class Application {

    public static void main(String[] args) {
        Application application = new Application();
        int a = 5;
        boolean b = false;
        application.outAge(a,b);
        System.out.println(a);//5
        System.out.println(b);//false
    }
    
    public void outAge(int a,boolean b){
        a = 10;
        b = true;
    }
}

4.方法参数传递-对象类型

对于引用类型的方法参数，会将外部变量的引用地址，复制一份到方法的局部变量中，两个地址指向同一个对象。

package com.xl;

/**
 * @author 小李同学
 * @pageage com.xl
 * @date 2021/1/24 14:16
 * @week 星期日
 */
public class Application {

    public static void main(String[] args) {
        Application application = new Application();
        User user = new User();
        user.age = 24;
        application.outAge(user);
        System.out.println(user.age);//100
    }

    public void outAge(User user1){
       user1.age = 100;
    }
}

5.static关键字

当声明一个事物是static时，就意味着这个域或者方法不会与包含它的那个类的任何对象实例关联在一起。
它的存储只有一份作用于整个类。


注意：static方法不能直接访问或调用其他非static域或者方法，因为非static域或者方法必须与某一个对象关
联。但是 非static方法可以直接访问static域或者方法。

public class UserRun {
    String name = "张三";

    public static void c(){
        //无法访问 编译错误
        System.out.println(name);
    }
}


public class UserRun {
   

    public void getName(){
        System.out.println("张三");
    }
    
    public static void c(){
        //无法访问 编译错误
        getName();
    }
}

6.true|false

Java不允许将一个数字作为布尔值使用，但是C和C++允许。在C和C++中，"真"是非零，而"假"是零。

7.构造器

构造器是对象在初始化时，自动调用的一个方法。Java中规定构造器方法的名称必须和类名相同，所以需要注意
一个点。就是"每个方法首字母小写"的编程风格并不适用与构造器。

注意：
构造器是一种特殊类型的方法，它没有返回值。这个与返回值void不同。

对于通过new 表达式创建并返回了一个对象的引用，但是构造器本身并没有任何返回值。

1.构造器里面不能同时调用多个构造器

public class Person {

    private String name;

    private int age;

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

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

    public Person(String name, int age) {
        //调用构造器 Person(String name)
        this(name);
        /**
         * 调用构造器 Person(int age)
         * 构造器里面不能同时调用多个构造器
         * 上面已经调用了Person(String name)
         * 下面接着调用Person(int age)程序就会报错
         */
        this(age); //报错
    }
}

2.除构造器之外 编译器禁止在其它方法内调用构造器
public class Person {

    private String name;

    private int age;

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

    public Person(int age) {
        this.age = age;
    }
    
    public void outAge(){
        /**
         * 除构造器之外 编译器禁止
         * 在其它方法内调用构造器
         */
        this("张三"); //报错
                
    }
}

8.方法重载

方法名相同，而方法的参数类型或参数的位置顺序不同。这样就称为方法的重载。


注意：
不能根据方法的返回值类型不同，来区分方法的重载。因为编译器无法根据语境来判断出具体调用的哪个方法。

9.finalize()方法

1.垃圾回收器只知道释放那些经由new分配的内存。

假设你的对象不是通过new分配的内存，那么垃圾回收器是不知道如何释放该对象的内存空间。

为了应对这种情况，java允许在类中定义一个名为finalize()的方法。一旦垃圾回收器准备释放对象占用的内
存空间时，将首先调用其finalize()方法。所以 你要是想在对象被回收前做一些操作，就需要实现finalize()
方法。


举例：
当你对象是通过本地方法构建的，比如调用C的malloc()函数系列来分配存储空间，而且除非调用了free()函
数,否则存储空间将得不到释放，从而造成内存泄漏。当然，free()是C和C++中的函数，所以需要在finalize
()中用本地方法调用。



注意：Java中对象可能不被垃圾回收。

public class Person {
    
    @Override
    protected void finalize() throws Throwable {
        /**
         * 伪代码
         * 调用本地方法free()函数释放对象内存空间
         * free()
         */

        System.out.println("finalize~~~~~~~~~~");
    }

    public static void main(String[] args) throws Throwable{
        Person person = new Person();
        person.finalize();
    }
}

10.数组

1.补充点1   

 public static void main(String[] args) {
        Integer[] arr = {
                new Integer(1),
                new Integer(2),
                3,
                4, //这种形式 初始化列表的最后一个逗号是可选的 最后一个元素后面跟着一个逗号不会报错
        };
        System.out.println(Arrays.toString(arr));
    }

11.可变参数列表

1、可变参数应用在参数个数未知的场景。
当你指定参数时，编译器实际上会为你去填充数组。你获取的仍旧是一个数组。所以也可以直接将数组传递到可
变参数中。

public class VarargsMain {


    public static void main(String[] args) {
        intVarargsMethod(1,2,3);
        intVarargsMethod(4,new Integer(5),new Integer(6));
        intVarargsMethod(new Integer[]{7,8,9});
    }

    public static void intVarargsMethod(Integer ...iarrs) {
        for (Integer value : iarrs) {
            System.out.print("Integet value:" + value+" ");
        }
        System.out.println("\n");
    }
}

输出：
Integet value:1 Integet value:2 Integet value:3 

Integet value:4 Integet value:5 Integet value:6 

Integet value:7 Integet value:8 Integet value:9 


2、可变参数搭配普通参数使用

public class VarargsMain {


    public static void main(String[] args) {
        //intVarargsMethod(1, 2, 3);
        //intVarargsMethod(4, new Integer(5), new Integer(6));
        //intVarargsMethod(new Integer[]{7, 8, 9});
        strVarargsMethod(1, "不积跬步", "无以至千里", "中秋节");
        strVarargsMethod(2);
    }


    public static void strVarargsMethod(Integer intValue, String... sarrs) {
        System.out.print("intValue:" + intValue + " ");
        for (String value : sarrs) {
            System.out.print("String value:" + value + " ");
        }
        System.out.println("\n");
    }
}

输出：
intValue:1 String value:不积跬步 String value:无以至千里 String value:中秋节 

intValue:2 

3、可变参数方法重载说明

需要用非可变参数区分

public class VarargsMain {


    public static void main(String[] args) {
        //intVarargsMethod(1, 2, 3);
        //intVarargsMethod(4, new Integer(5), new Integer(6));
        //intVarargsMethod(new Integer[]{7, 8, 9});
        //strVarargsMethod(1, "不积跬步", "无以至千里", "中秋节");
        //strVarargsMethod(2);

        charVarargsMethod(1, 'a', 'c', 'd');
        charVarargsMethod('a', 'c', 'd');
    }


    public static void charVarargsMethod(Integer intValue, Character... carrs) {
        System.out.print("intValue:" + intValue + " ");
        for (Character value : carrs) {
            System.out.print("char value:" + value + " ");
        }
        System.out.println("\n");
    }

    public static void charVarargsMethod(Character... carrs) {
        for (Character value : carrs) {
            System.out.print("char value:" + value + " ");
        }
        System.out.println("\n");
    }
}

输出:
intValue:1 char value:a char value:c char value:d 

char value:a char value:c char value:d

12.枚举类型

JavaSE5添加了一个很小的特性，即enum关键字。枚举类型的实例是常量，因此按照命名惯例它们都用大写字母
表示，如果一个枚举值有多个单词，用下划线分隔开。



1、创建枚举时，编译器还会创建ordinal()方法，用来表示enum常量的声明顺序，以及values()方法，
用来按照enum常量的声明顺序，产生由这些常量值构成的数组；

public class SpicinessEnumMain {

    public static void main(String[] args) {

        System.out.println(SpicinessEnum.NOT);
        System.out.println(SpicinessEnum.NOT.name());

        SpicinessEnum hot = SpicinessEnum.HOT;
        System.out.println(hot);

        System.out.println("---------------------------");

        for(SpicinessEnum enumValue:SpicinessEnum.values()){
            System.out.println(enumValue+",创建顺序"+enumValue.ordinal());
        }
    }
}

输出:
NOT
NOT
HOT
---------------------------
NOT,创建顺序0
MILD,创建顺序1
MEDIUM,创建顺序2
HOT,创建顺序3
FLAMING,创建顺序4