Java核心技术卷一笔记

时间：2022-06-02 16:18:01

打印集合中所有的元素

        int [] a = {1,23,13,25};
/**
 * 打印方式一
 * */
        System.out.println(Arrays.toString(a));
/**
 * 打印方式二
 * */
for (int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
/**
 * 打印方式三
 * */
for (int b: a
             ) {
            System.out.println(b);
        }

输出：

[1, 23, 13, 25]
1
23
13
25
1
23
13
25

在java中，允许数组长度为0，所以我们可以创建一个长度为0的数组：

new arr[0]

但是这个时候的长度为0的数组和数组为null是不同的
例如：

       int [] a = {};
for(int i = 0;i<a.length;i++){
            System.out.println(a);
        }

这个时候的控制台是没有打印出东西的，但是如果数组中为null的话，如果我们使用a.length()这个方法的话，会报空指针异常，因为数组为null的话，是没有length这个方法的

数组拷贝

        /**
 * 将一个数组的值拷贝到另一个新的数组中去
 * */
int [] a = {1,3,5,7,9};
/**
 * 这个是按照原长度的数组拷贝进去的
 * */
int [] b = Arrays.copyOf(a,a.length);
/**
 * 这个还可以指定数组长度的大小，比如指定四倍长度大小的数组
 * 如果数组元素是整形的话，多余的元素将会被赋值为0，如果数组元素是布尔型，则将赋值为false
 * 如果长度小于原始数组的长度，则只拷贝最前面的数组元素
 * */
int [] c = Arrays.copyOf(a,4*a.length);

Java中的命令行参数

每个主方法都有一个String arg[]的参数，意思是main方法将接收一个字符串数组

数组排序

        /**
 * 数组排序
 * */
int [] a = {12,4,23,11,57,98};
        Arrays.sort(a);
for (int i= 0 ;i<a.length;i++){
            System.out.println(a[i]);
        }

输出：

4
11
12
23
57
98

OOP的特性

对象的行为：可以对对象施加哪些操作，或可以对对象施加哪些方法？
对象的状态：当施加那些方法时，对象如何响应？
对象的标识：如何辨别具有相同行为与状态不同对象？

类之间的关系

依赖
聚合（关联）
继承

日期类

        /**
 * Date类
 * */
        String s = new Date().toString();
        System.out.println(s);
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        System.out.println(sf.format(new Date()));

输出结果：
Fri Dec 29 14:07:06 GMT+08:00 2017

2017-07-29 14:07:06

对象的认识

一定要认识到：一个对象变量并没有实际包含一个对象，而仅仅是引用一个对象，在Java中，任何对象变量都是对存储在另外一个地方的一个对象的引用，new操作符的返回值也是一个引用。
内存中存储的变量和内存的地址，相当于C中的指针
Java中的堆和栈，要区分一下这个东西

Java中的localDate类

        /**
 * Java中的时间类有两种：
 * 第一种是表示时间点的Date类
 * 第二种是日历表示法的LocalDate类
 * */
        LocalDate date = LocalDate.now();
            System.out.println(date);
int year = date.getYear();
int month = date.getMonthValue();
int day = date.getDayOfMonth();
            System.out.println(year);
            System.out.println(month);
            System.out.println(day);

输出：
2017-12-29
2017
12
29

LocalDate类的补充

        /**
 * LocalDate类的补充
 * */

/**
 * 获取今天的日期
 * */
        LocalDate date = LocalDate.now();
/**
 * 获取这个月的月份
 * */
int month = date.getMonthValue();
/**
 * 获取今天的日
 * */
int today = date.getDayOfMonth();
/**
 * 获取这个月的第一天
 * */
        LocalDate fristday = date.minusDays(today-1);
/**
 * 获取今天是星期几，并输出打印
 * */
        DayOfWeek weekday = date.getDayOfWeek();
int value = weekday.getValue();
        System.out.println(value);
        System.out.println(fristday);

Java中的注释

最好采用javadoc的形式：
/**
 * @author qxf
 * @param 变量描述
 * @return 返回值描述
 * @throws 有可能抛出异常的方法
 * */

类设计技巧

一定要保证数据私有
一定要对数据进行初始化
不要在类中使用过多的基本类型
不是所有的域都需要独立的域访问器和域更改器
类名和方法名要能够体现他们的职责
优先使用不可变类：LocalDate类以及java.time包中的其他类是不可变的，没有方法能修改对象的状态。更改对象的问题在于，如果多线程试图同时更新一个对象，就会发生并发更改，其结果是不可预料的，如果类是不可变的，就可以安全地在多个线程之间共享其对象。

Java中的继承

    继承已经存在的类就是复用这些类和域，在此基础上，还可以添加一些新的方法和域，以满足新的需求，这是Java中的一项核心的技术。
    反射是指程序在运行的期间发现更多的类及其属性的能力。
    一个对象变量可以指示多种实际类型的现象被称为多态，在运行时能够自动地的选择调用哪个方法的现象称为动态绑定。
    Java不支持多继承
    有时候人们希望组织利用某个类定义子类，不允许扩展的类被称为final类。如果在定义类的时候使用了final修饰符就表明这个类是final类。
    类即使不含抽象方法，也可以将类声明为抽象类。
    抽象类不能被实例化，也就是说，如果将一个类声明为abstart，就不能创建这个类的对象。
    设计继承的技巧：
    1，将公共操作和域放在超类
    这就是为什么将姓名域放在Person类中，而没有将它放在Employee和Student类中的原因。
    2，不要使用受保护的域
    意思就是不要使用protected定义作用域
    3，除非所有继承的方法都有意义，否则不要使用继承
    4，不要过多的使用反射，反射机制使得人们可以通过在运行时查看域和方法，让人们编写出更具有通用性的程序，这种功能对于编写系统程序来说极其实用，但是通常不适于编写应用程序，反射是很脆弱的，即编译器很难帮助人们发现程序中的错误，因此只有在运行时才发现错误并导致异常。

Java中的访问控制符

1）仅对本类可见：private
2）对所有类可见：public
3）对本包和所有子类可见：protected
4）对本包可见：默认

定义一个枚举类

    public enum Size{
/**
 * 小号
 * */
        small,
/**
 * 中号
 * */
        middle,
/**
 * 大号
 * */
        big;
    };

反射

    反射库提供了一个非常丰富的工具集，以便编写能够动态操纵Java代码的程序，这项功能被大量的应用于JavaBean中，它是Java组件的体系结构，使用反射，在设计或者运行中添加新类的时候，能够快速的应用开发工具动态的查询新添加类的功能。
    能够分析类能力的程序称为反射，反射机制的功能极其强大。
    反射的包是java.lang.reflect，包中有三个类：Field，Method，Constructor分别用于描述类的域，方法和构造器。
package com.demo.test;


import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;

/**
 *
 * @author qxf
 * @version 1.0 2017-12-30
 *
 * */
public class TestReflection {
public static void main(String args[]){
        String name;
/**
 * 取main方法的args数组，如果args数组不为空，将args数组的第一位赋值给name
 * */
if(args.length>0){
            name = args[0];
        }else {
/**
 * 获取用户输入的类名
 * */
            Scanner in = new Scanner(System.in);
            System.out.println("请输入一个类名：例如：java.util.Date");
            name = in.next();
        }

try {
/**
 * 定义一个类，用于在运行时获取类的名称
 * */
            Class cl = Class.forName(name);
/**
 * 定义一个父类变量，用于获取用户输入的类的父类名称
 * */
            Class supercl = cl.getSuperclass();
/**
 * 返回对应 modifiers 中位设置的修饰符的字符串表示
 * */
            String modifiers = Modifier.toString(cl.getModifiers());
if(modifiers.length()>0){
                System.out.println(modifiers+"");
            }
            System.out.println("class "+name);
if(supercl!=null&&supercl!=Object.class){
                System.out.println("extends "+supercl.getName());
                System.out.println("\n{\n");
                printConstructors(cl);
                System.out.println();
                printMethod(cl);
                System.out.println();
                printFields(cl);
                System.out.println("}");
            }
        }catch (Exception e){
                e.printStackTrace();
        }
        System.exit(0);
    }

public static void printConstructors(Class cl){
        Constructor [] constructors = cl.getConstructors();
for (Constructor c:constructors
             ) {
            String name = c.getName();
            System.out.println(" ");
            String modifiers = Modifier.toString(c.getModifiers());
if(modifiers.length()>0){
                System.out.println(modifiers + "");
                System.out.println(name + "(");
            }
            Class [] paraTypes = c.getParameterTypes();
for(int j=0;j<paraTypes.length;j++){
if(j>0){
                    System.out.println(",");
                    System.out.println(paraTypes[j].getName());
                }
                System.out.println(");");
            }
        }
    }

public static void printMethod(Class cl){
        Method [] methods = cl.getMethods();
for(Method m : methods){
            Class retType = m.getReturnType();
            String name = m.getName();
            System.out.println(" ");
            String modifiers = Modifier.toString(m.getModifiers());
if(modifiers.length()>0){
                System.out.println(modifiers + "");
                System.out.print(retType.getName()+" "+name+"(");
            }
            Class [] paramTypes = m.getParameterTypes();
for (int j=0;j<paramTypes.length;j++){
if(j>0){
                    System.out.println(",");
                    System.out.println(paramTypes[j].getName());
                }
            }
            System.out.println(");");
        }
    }

public static void printFields(Class cl){
        Field [] fields = cl.getFields();
for (Field f : fields){
            Class type = f.getType();
            String name = f.getName();
            System.out.println(" ");
            String modifiers = Modifier.toString(f.getModifiers());
if(modifiers.length()>0){
                System.out.println(modifiers+ " ");
                System.out.println(type.getName()+" "+name+";");
            }
        }
    }
}

捕获异常

    当程序运行时发生错误的时候，就会抛出异常，抛出异常比终止异常要好的多，因为如果一旦终止了程序，会给用户造成很不好的用户体验。
    异常有两种类型：
        未检查异常和已检查异常
    并不是所有异常编译器都可以帮助我们检查出来，而我们在程序设计中最常用的就是try-catch
public void test(){
try {
            System.out.println("如果发生异常");
        }catch (Exception e){
            System.out.println("就到这里来");
        }
    }
这就是一个最常见的异常处理

接口

    接口技术，这种技术主要用于描述类具有什么功能，而并不给出每个功能的具体实现，一个类可以实现一个或者多个接口，并在需要接口的地方，随时使用。
标签：

相关文章