MRVLSteven
MRVLSteven

Javase基础

一、基础数据结构

四类八种

整形：byte short int long

浮点型：float double

布尔值：boolean

字符型：char

1、取值范围：

整形：byte -2^7~2^7-1  10000000(-128)

浮点型：符号位+阶码（指数为）+尾数

char一个字符连个字节（unicode）

2、字符发展

ASCII（七位）->ISO8859-1（单字节）->unicode（两个字节）

->utf-8（可变长的字符集，英文一个字节，中文三个字节）

GBK GB2312中国的国标字符集

3、变量

变量的类型 变量的名字 = 具体的值；

定义和赋值两部分

他在内存里开辟了一片空间，可以存数据

他可以反复的到处使用

变量其实就是一个引用，他指向堆内存的一块区域，我们想操作一个对象只需要使用它的引用即可

4、标识符命名规则

可以用下划线_和$但是不建议使用

可以用数字和字母，但是数字不能开头

不能使用关键字

所有的名字必须驼峰式命名、变量、方法首字母小写，类名首字母。静态常量全部大写用下划线分割。

尽量少用拼音，如果要用就整体都是拼音，不能拼音加因为

二、运算符

1、逻辑运算符

与 (&)： 全部为真才是真，有一个是假就是假 串联电路 1 & 1 = 1；0 & 0 = 0；1 & 0 = 0

或 (|)：全部为假才是假，有一个为真就是真 并联电路 1 | 1 = 1； 1 | 0 = 1；0 | 0 =0

非(!)： 非真即是假 非假就是真

异或(^)： 相同为假，不同为真 1 ^ 1 = 0; 0 ^ 0 =0; 1 ^ 0 =1

双与(&&)：短路运算符，前边为假直接返回假，后边的就不进行计算了

双或(||)：短路运算符，前边为真直接返回真，后边的就不进行j计算了

2、算术运算符

加 减 乘 除 取余

3、赋值运算符

=

++

--

+=

-=

4、位移运算符

>>有符号右移

<<有符号左移

>>>无符号右移

5、三目运算符

条件？结果一：结果二

三、流程控制语句

if语句

if(i==0){

}else{

}

if(i==0){

}

if(i!=2){

}

switch语句

//i可以是byte short int String enum的数据

switch(i){

case1:

System.out.println();

break;

case2:

System.out.println();

break;

default:

System.out.println();

  break;

}

while语句

//如果不是死循环，一定要想办法退出

booleanflag=true;

while(flag){

    if(条件)

flag=false

}

do{

if(条件)

flag=false

}while(flag);

for语句

for(inti=0;i<10;i++){

}

四、数组

1、定义

类型 名字[] = new 类型[长度]

类型 名字[] = {1,2,3}

类型 名字[]; 名字  =  new 类型[]{1,2,3,4};

2、特性

一旦创建就不能改变，类型不能改，长度不能改

length代表他的长度

下表从零开始，最后一个是length-1

名字[下标] = 0;

如果使用时超出下标，ArrayIndexOutOfBoundsException

3、几个例子

遍历、取最大最小值、求和、交换

inttemp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

五、方法

权限修饰符（static静态）(泛型) 返回值类型 名字 （参数）{}

1、权限修饰符

修饰词本类同一个包的类继承类其他类

private√×××

无（默认）√√××

protected√√√×

public√√√√

2、返回值类型

3、可变参数

只能出现一次

必须放在最后

调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中一数组的形式访问可变参数。

publicvoidf1(int...nums)

4、方法的重载

方法名一样

参数列表不一样

每一个方法都有个签名 就是用名字和参数签名的

六、面向对象

1、封装

需要什么对象，就创建一个什么类，万物皆对象

publicclassUser{

// 私有的属性

//构造器

//实例方法

//getter and setter

//toString（如果需要）

}

可能还用工具类和常量类，工具类里一般大多都是静态方法，常量类里大多是静态常量

publicstaticfinalStringORDER_STATUS="已发货"

1.1属性

属性全部私有，使用getter取值，使用setter赋值，能做安全控制

1.2方法

1.3构造器

new 一个对象会主动调用他的构造器

构造器可以有多个，可以有不同参数的构造器

构造器如果不写，或默认送你一个无参构造，一旦你写了有参构造方法，无参构造器需要手写

2、继承

extends关键字，子类拥有父类（超类）一切（除了被private修饰的）

构造子类时，一定会先构造一个父类

父类的静态字段——>父类静态代码块——>子类静态字段——>子类静态代码块——>父类成员变量（非静态字段）——>父类非静态代码块——>父类构造器——>子类成员变量——>子类非静态代码块——>子类构造器

子类可以重写父类的方法，重写的方法需要加一个注解@override

Object是所有类的顶级父类

3、多态

有继承

有重写

有父类引用指向子类对象

Listlist=newArrayList<>();

list.add(1);

4、抽象类和接口

抽象类：拥有抽象方法的类，必须使用abstract修饰

继承抽象类必须实现它的抽象方法

接口：全部都是抽象方法（没有方法体的方法）

实现接口必须实现所有的抽象方法

5、Object的几个方法

equals

hashcode（hash算法）

重写equals必须重写hashcode,主要是因为有hashmap,hashset这类的集合

toString()

6、this和super

this指向本实例

super指向父类的实例

this和super可以当构造器使用，如果想使用super()，必须放在第一行

7、类的加载顺序

父类的静态属性

父类的静态代码块

子类的静态属性

子类的静态代码块

父类的非静态属性

父类的非静态代码块

父类的构造器

子类的非静态属性

子类的非静态代码快

子类构造器

七、集合

集合是存东西的，能存很多同一种类型（包含他的子类）的对象

1、Collection

2、list（列表）

需要定义泛型

ArrayLIst和LInkedLIst

区别：

ArrayList基于动态数组实现的非线程安全的集合；LinkedList基于链表实现的非线程安全的集合。

对于随机index访问的get和set方法，一般ArrayLIst的速度要由于LinkedLIst。因为ArrayList直接通过数组下标直接找到元素；LinkedList要移动指针遍历每个元素知道找到为止。

新增和删除元素，一般LinkedList的速度要优于ArrayList。因为ArrayList在新增和删除元素时，可能扩容和复制数组；LinkedList实例化对象需要时间外，只需要修改指针即可。

LinkedList集合不支持高效的随机访问（RandomAccess）。

ArrayList的空间浪费主要体现在在list列表的结尾要预留一定的容量空间，而LinkedList的空间话费则体现在它的每一个元素都需要消耗相当的空间。

3、set

set和list的区别

list：有序（插入的顺序），可重复

set：无序，不可重复

hashset：怎么判断一个对象是不是重复的：equals和hashcode这两个方法，如果两个对象不是用一个地址但是他们 equal，并且hashcode一样就说明一样

4、map（映射）

hashmap最重要的集合，如果有兴趣可以看看hashmap的源码解读，特别复杂

5、集合的遍历方式

list的遍历方式：普通for循环，增强for循环，迭代器（iterator)

set的遍历方式：不能用普通for循环，增强for循环，迭代器（iterator)

hashmap的遍历方式：entrySet来遍历，还能用迭代器

ArrayList

List list=new ArrayList();

    list.add("Hello");

    list.add("World");

    list.add("HAHAHAHA");

//第一种遍历方法使用 For-Each 遍历 List

for (String str : list) {            //也可以改写 for(int i=0;i

    System.out.println(str);

}

//第二种遍历，把链表变为数组相关的内容进行遍历

String[] strArray=new String[list.size()];

list.toArray(strArray);

for(int i=0;i

{

    System.out.println(strArray[i]);

}

//第三种遍历 使用迭代器进行相关遍历

Iterator ite=list.iterator();

while(ite.hasNext())//判断下一个元素之后有值

{

    System.out.println(ite.next());

}

Map

  Map map = new HashMap();

  map.put("1", "value1");

  map.put("2", "value2");

  map.put("3", "value3");

  //第一种：普遍使用，二次取值

  System.out.println("通过Map.keySet遍历key和value：");

  for (String key : map.keySet()) {

  System.out.println("key= "+ key + " and value= " + map.get(key));

  }

  //第二种

  System.out.println("通过Map.entrySet使用iterator遍历key和value：");

  Iterator> it = map.entrySet().iterator();

  while (it.hasNext()) {

  Map.Entry entry = it.next();

  System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());

  }

  //第三种：推荐，尤其是容量大时

  System.out.println("通过Map.entrySet遍历key和value");

  for (Map.Entry entry : map.entrySet()) {

  System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());

  }

  //第四种

  System.out.println("通过Map.values()遍历所有的value，但不能遍历key");

  for (String v : map.values()) {

  System.out.println("value= " + v);

  }

}

八、泛型

1、什么是泛型？

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常.

泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

参数化类型:

把类型当作是参数一样传递

<数据类型> 只能是引用类型

2、泛型基础

2.1泛型类

泛型类就是把泛型定义在类上，用户使用该类的时候，才把类型明确下来....这样的话，用户明确了什么类型，该类就代表着什么类型...用户在使用的时候就不用担心强转的问题，运行时转换异常的问题了。

在类上定义的泛型，在类的方法中也可以使用！

/*

    1:把泛型定义在类上

    2:类型变量定义在类上,方法中也可以使用

*/

public class ObjectTool {

    private T obj;

    public T getObj() {

        return obj;

    }

    public void setObj(T obj) {

        this.obj = obj;

    }

}

测试代码：

用户想要使用哪种类型，就在创建的时候指定类型。使用的时候，该类就会自动转换成用户想要使用的类型了。

    public static void main(String[] args) {

        //创建对象并指定元素类型

        ObjectTool tool = new ObjectTool<>();

        tool.setObj(new String("钟福成"));

        String s = tool.getObj();

        System.out.println(s);

        //创建对象并指定元素类型

        ObjectTool objectTool = new ObjectTool<>();

        /**

        * 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.

        */

        objectTool.setObj(10);

        int i = objectTool.getObj();

        System.out.println(i);

    }

2.2泛型方法

前面已经介绍了泛型类了，在类上定义的泛型，在方法中也可以使用.....

现在呢，我们可能就仅仅在某一个方法上需要使用泛型....外界仅仅是关心该方法，不关心类其他的属性...这样的话，我们在整个类上定义泛型，未免就有些大题小作了。

定义泛型方法....泛型是先定义后使用的

    //定义泛型方法..

    public void show(T t) {

        System.out.println(t);

    }

测试代码：

用户传递进来的是什么类型，返回值就是什么类型了

    public static void main(String[] args) {

        //创建对象

        ObjectTool tool = new ObjectTool();

        //调用方法,传入的参数是什么类型,返回值就是什么类型

        tool.show("hello");

        tool.show(12);

        tool.show(12.5);

    }

2.3泛型类派生出的子类

前面我们已经定义了泛型类，泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承

那它是怎么被继承的呢？？这里分两种情况

子类明确泛型类的类型参数变量

子类不明确泛型类的类型参数变量

2.3.1子类明确泛型类的类型参数变量

泛型接口

/*

    把泛型定义在接口上

*/

public interface Inter {

    public abstract void show(T t);

}

实现泛型接口的类.....

/**

* 子类明确泛型类的类型参数变量:

*/

public class InterImpl implements Inter {

    @Override

    public void show(String s) {

        System.out.println(s);

    }

}

2.3.2子类不明确泛型类的类型参数变量

当子类不明确泛型类的类型参数变量时，外界使用子类的时候，也需要传递类型参数变量进来，在实现类上需要定义出类型参数变量

/**

* 子类不明确泛型类的类型参数变量:

*      实现类也要定义出类型的

*

*/

public class InterImpl implements Inter {

    @Override

    public void show(T t) {

        System.out.println(t);

    }

}

测试代码:

    public static void main(String[] args) {

        //测试第一种情况

        //Inter i = new InterImpl();

        //i.show("hello");

        //第二种情况测试

        Inter ii = new InterImpl<>();

        ii.show("100");

    }

值得注意的是：

实现类的要是重写父类的方法，返回值的类型是要和父类一样的！

类上声明的泛形只对非静态成员有效

3、类型通配符

为什么需要类型通配符？？？？我们来看一个需求.......

现在有个需求：方法接收一个集合参数，遍历集合并把集合元素打印出来，怎么办？

按照我们没有学习泛型之前，我们可能会这样做：

public void test(List list){

    for(int i=0;i

        System.out.println(list.get(i));

    }

}

上面的代码是正确的，只不过在编译的时候会出现警告，说没有确定集合元素的类型....这样是不优雅的...

那我们学习了泛型了，现在要怎么做呢？？有的人可能会这样做：

public void test(List list){

    for(int i=0;i

        System.out.println(list.get(i));

    }

}

这样做语法是没毛病的，但是这里十分值得注意的是：该test()方法只能遍历装载着Object的集合！！！

强调：泛型中的并不是像以前那样有继承关系的，也就是说List和List是毫无关系的！！！！

那现在咋办？？？我们是不清楚List集合装载的元素是什么类型的，List这样是行不通的........于是Java泛型提供了类型通配符 ?

所以代码应该改成这样：

public void test(List list){

    for(int i=0;i

        System.out.println(list.get(i));

    }

}

?号通配符表示可以匹配任意类型，任意的Java类都可以匹配.....

现在非常值得注意的是，当我们使用?号通配符的时候：就只能调对象与类型无关的方法，不能调用对象与类型有关的方法。

记住，只能调用与对象无关的方法，不能调用对象与类型有关的方法。因为直到外界使用才知道具体的类型是什么。也就是说，在上面的List集合，我是不能使用add()方法的。因为add()方法是把对象丢进集合中，而现在我是不知道对象的类型是什么。

3.1设定通配符上限

首先，我们来看一下设定通配符上限用在哪里....

现在，我想接收一个List集合，它只能操作数字类型的元素【Float、Integer、Double、Byte等数字类型都行】，怎么做？？？

我们学习了通配符，但是如果直接使用通配符的话，该集合就不是只能操作数字了。因此我们需要用到设定通配符上限

List

上面的代码表示的是：List集合装载的元素只能是Number的子类或自身

    public static void main(String[] args) {

        //List集合装载的是Integer，可以调用该方法

        List integer = new ArrayList<>();

        test(integer);

        //List集合装载的是String，在编译时期就报错了

        List strings = new ArrayList<>();

        test(strings);

    }

    public static void test(List list) {

    }

3.2设定通配符下限

既然上面我们已经说了如何设定通配符的上限，那么设定通配符的下限也不是陌生的事了。直接来看语法吧

    //传递进来的只能是Type或Type的父类

   

设定通配符的下限这并不少见，在TreeSet集合中就有....我们来看一下

    public TreeSet(Comparator comparator) {

        this(new TreeMap<>(comparator));

    }

那它有什么用呢？？我们来想一下，当我们想要创建一个TreeSet类型的变量的时候，并传入一个可以比较String大小的Comparator。

那么这个Comparator的选择就有很多了，它可以是Comparator，还可以是类型参数是String的父类，比如说Comparator....

这样做，就非常灵活了。也就是说，只要它能够比较字符串大小，就行了

经评论去补充：在泛型的上限和下限中有一个原则：PECS(Producer Extends Consumer Super)

书上是这样写的：

带有子类限定的可以从泛型读取【也就是--->(? extend T)】-------->Producer Extends带有超类限定的可以从泛型写入【也就是--->(? super T)】-------->Consumer Super也有相关博文写得很好：

http://blog.51cto.com/flyingc...https://blog.csdn.net/xx32666...

4、通配符和泛型方法

大多时候，我们都可以使用泛型方法来代替通配符的.....

    //使用通配符

    public static void test(List list) {

    }

    //使用泛型方法

    public void  test2(List t) {

    }

上面这两个方法都是可以的.....那么现在问题来了，我们使用通配符还是使用泛型方法呢？？

原则：

如果参数之间的类型有依赖关系，或者返回值是与参数之间有依赖关系的。那么就使用泛型方法

如果没有依赖关系的，就使用通配符，通配符会灵活一些.

5、泛型擦除

泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。

6、兼容性

JDK5提出了泛型这个概念，但是JDK5以前是没有泛型的。也就是泛型是需要兼容JDK5以下的集合的。

当把带有泛型特性的集合赋值给老版本的集合时候，会把泛型给擦除了。

值得注意的是：它保留的就类型参数的上限。

        List list = new ArrayList<>();

        //类型被擦除了，保留的是类型的上限，String的上限就是Object

        List list1 = list;

如果我把没有类型参数的集合赋值给带有类型参数的集合赋值，这又会怎么样？？

        List list = new ArrayList();

        List list2 = list;

它也不会报错，仅仅是提示“未经检查的转换”

九、多线程

1、进程和线程

进程：是正在运行的程序

是系统进行资源分配和调用的独立单位

每一个进程都有它自己的内存空间和系统资源

线程：是进程中的单个顺序控制流，是一条执行路径

单线程：一个进程如果只有一条执行路径，则称为单线程程序

多线程：一个进程如果有多条执行路径，则称为多线程程序

2、实现多线程的方式：

一、：继承Thread类

1、方法介绍

方法名说明

void run()在线程开启后，此方法将被调用执行

void start()使此线程开始执行，Java虚拟机会调用run方法()

2、实现步骤

定义一个类MyThread继承Thread类

在MyThread类中重写run()方法

创建MyThread类的对象

启动线程

public class MyThread extends Thread {

    @Override

    public void run() {

        for(int i=0; i<100; i++) {

            System.out.println(i);

        }

    }

}

public class MyThreadDemo {

    public static void main(String[] args) {

        MyThread my1 = new MyThread();

        MyThread my2 = new MyThread();

//        my1.run();

//        my2.run();

        //void start() 导致此线程开始执行; Java虚拟机调用此线程的run方法

        my1.start();

        my2.start();

    }

}

注意：

为什么要重写run()方法？

因为run()是用来封装被线程执行的代码

run()方法和start()方法的区别？

run()：封装线程执行的代码，直接调用，相当于普通方法的调用

start()：启动线程；然后由JVM调用此线程的run()方法

3、设置和获取线程名称

方法名说明

void  setName(String name)将此线程的名称更改为等于参数name

String  getName()返回此线程的名称

Thread  currentThread()返回对当前正在执行的线程对象的引用

4、线程优先级

线程调度

两种调度方式

分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片

抢占式调度模型：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些

Java使用的是抢占式调度模型

随机性

假如计算机只有一个 CPU，那么 CPU 在某一个时刻只能执行一条指令，线程只有得到CPU时间片，也就是使用权，才可以执行指令。所以说多线程程序的执行是有随机性，因为谁抢到CPU的使用权是不一定的

优先级相关方法

方法名说明

final int getPriority()返回此线程的优先级

final void setPriority(int newPriority)更改此线程的优先级                                                                                        线程默认优先级是5；线程优先级的范围是：1-10

5、线程控制

相关方法

方法名说明

static void sleep(long millis)使当前正在执行的线程停留（暂停执行）指定的毫秒数

void join()等待这个线程死亡

void setDaemon(boolean on)将此线程标记为守护线程。当其他线程结束，守护线程也同时结束

6、线程的生命周期

线程一共有五种状态，线程在各种状态之间转换。

二、实现多线程方式二：实现Runnable接口

1、Thread构造方法

方法名说明

Thread(Runnable target)分配一个新的Thread对象

Thread(Runnable target, String name)分配一个新的Thread对象

2、实现步骤

定义一个类MyRunnable实现Runnable接口

在MyRunnable类中重写run()方法

创建MyRunnable类的对象

创建Thread类的对象，把MyRunnable对象作为构造方法的参数

启动线程

3、相比继承Thread类，实现Runnable接口的好处

避免了Java单继承的局限性

适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面向对象的设计思想

4、代码实现

public class SellTicket implements Runnable {

    private int tickets = 100;

    //在SellTicket类中重写run()方法实现卖票，代码步骤如下

    @Override

    public void run() {

        while (true) {

            if (tickets > 0) {

                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");

                tickets--;

            }

        }

    }

}

public class SellTicketDemo {

    public static void main(String[] args) {

        //创建SellTicket类的对象

        SellTicket st = new SellTicket();

        //创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称

        Thread t1 = new Thread(st,"窗口1");

        Thread t2 = new Thread(st,"窗口2");

        Thread t3 = new Thread(st,"窗口3");

        //启动线程

        t1.start();

        t2.start();

        t3.start();

    }

}

3、线程同步

1、同步代码块格式：

synchronized(任意对象) {

多条语句操作共享数据的代码

}

synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁

2、同步的好处和弊端 

好处：解决了多线程的数据安全问题

弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率

3、同步方法

1、同步方法的格式

同步方法：就是把synchronized关键字加到方法上

修饰符 synchronized 返回值类型 方法名(方法参数) {

方法体；

}

同步方法的锁对象是什么呢?

this

2、静态同步方法

同步静态方法：就是把synchronized关键字加到静态方法上

修饰符 static synchronized 返回值类型 方法名(方法参数) {

方法体；

}

同步静态方法的锁对象是什么呢?

类名.class

4、线程安全的类

StringBuffer

线程安全，可变的字符序列

从版本JDK 5开始，被StringBuilder 替代。 通常应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步

Vector

从Java 2平台v1.2开始，该类改进了List接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Vector被同步。 如果不需要线程安全的实现，建议使用ArrayList代替Vector

Hashtable

该类实现了一个哈希表，它将键映射到值。 任何非null对象都可以用作键或者值

从Java 2平台v1.2开始，该类进行了改进，实现了Map接口，使其成为Java Collections Framework的成员。 与新的集合实现不同， Hashtable被同步。 如果不需要线程安全的实现，建议使用HashMap代替Hashtable

5、Lock锁

Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化

1、ReentrantLock构造方法

方法名说明

ReentrantLock()创建一个ReentrantLock的实例

2、加锁解锁方法

方法名说明

void lock()获得锁

void unlock()释放锁

3、代码演示

public class SellTicket implements Runnable {

    private int tickets = 100;

    private Lock lock = new ReentrantLock();

    @Override

    public void run() {

        while (true) {

            try {

                lock.lock();

                if (tickets > 0) {

                    try {

                        Thread.sleep(100);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");

                    tickets--;

                }

            } finally {

                lock.unlock();

            }

        }

    }

}

public class SellTicketDemo {

    public static void main(String[] args) {

        SellTicket st = new SellTicket();

        Thread t1 = new Thread(st, "窗口1");

        Thread t2 = new Thread(st, "窗口2");

        Thread t3 = new Thread(st, "窗口3");

        t1.start();

        t2.start();

        t3.start();

    }

}

十、常用类

1、String

String是引用数据类型，它是final的，一旦创建就不能改变。

String,StringBuffer,StringBuilder的区别面试常问。

String是不可变的，线程安全的

StringBuffer是可变字符串，线程安全

StringBulider是可变字符串，线程不安全

当有大量字符串拼接的代码时，没有线程安全的要就就使用StringBuilder（一般情况），有要求就用StringBuffer

2、工具类

Data Math Collections Arrays Canlader

十一、枚举

1、定义枚举类型

定义枚举类型需要使用enum关键字，例如：

枚举可以用equals来比较，也可以用==来比较

public enum Direction {

    FRONT, BEHIND, LEFT, RIGHT;

}

Direction d = Direction.FRONT;

2、枚举与switch

枚举类型可以在switch中使用

Direction d = Direction.FRONT;

  switch(d) {

    case FRONT: System.out.println("前面");break;

    case BEHIND:System.out.println("后面");break;

    case LEFT:  System.out.println("左面");break;

    case RIGHT: System.out.println("右面");break;

    default:System.out.println("错误的方向");

}

Direction d1 = d;

System.out.println(d1);

3、枚举的方法

int compareTo(E e)：比较两个枚举常量谁大谁小，其实比较的就是枚举常量在枚举类中声明的顺序，例如FRONT的下标为0，BEHIND下标为1，那么FRONT小于BEHIND；

boolean equals(Object o)：比较两个枚举常量是否相等；

int hashCode()：返回枚举常量的hashCode；

String name()：返回枚举常量的名字；

int ordinal()：返回枚举常量在枚举类中声明的序号，第一个枚举常量序号为0；

String toString()：把枚举常量转换成字符串；

static T valueOf(Class enumType, String name)：把字符串转换成枚举常量。

枚举类的构造器枚举类也可以有构造器，构造器默认都是private修饰，而且只能是private。因为枚举类的实例不能让外界来创建！

enum Direction {

    FRONT, BEHIND, LEFT, RIGHT;//[在枚举常量后面必须添加分号，因为在枚举常量后面还有其他成员时，分号是必须的。枚举常量必须在枚举类中所有成员的上方声明。]

    Direction()//[枚举类的构造器不可以添加访问修饰符，枚举类的构造器默认是private的。但你自己不能添加private来修饰构造器。] {

        System.out.println("hello");

    }

}

其实创建枚举项就等同于调用本类的无参构造器，所以FRONT、BEHIND、LEFT、RIGHT四个枚举项等同于调用了四次无参构造器，所以你会看到四个hello输出。

5、枚举类可以有成员

其实枚举类和正常的类一样，可以有实例变量，实例方法，静态方法等等，只不过它的实例个数是有限的，不能再创建实例而已。

enum Direction {

    FRONT("front"), BEHIND("behind"), LEFT("left"), RIGHT("right");

    private String name;

    Direction(String name) {

        this.name = name;

    }

    public String getName() {

        return name;

    }

}

Direction d = Direction.FRONT;

System.out.println(d.getName());

因为Direction类只有唯一的构造器，并且是有参的构造器，所以在创建枚举项时，必须为构造器赋值：FRONT(“front”)，其中”front”就是传递给构造器的参数。你不要鄙视这种语法，你应该做的是接受这种语法！ Direction类中还有一个实例域：String name，我们在构造器中为其赋值，而且本类还提供了getName()这个实例方法，它会返回name的值。

6、枚举类中还可以有抽象方法

还可以在枚举类中给出抽象方法，然后在创建每个枚举项时使用“特殊”的语法来重复抽象方法。所谓“特殊”语法就是匿名内部类！也就是说每个枚举项都是一个匿名类的子类对象！

通常fun()方法应该定义为抽象的方法，因为每个枚举常量都会去重写它。 你无法把Direction声明为抽象类，但需要声明fun()方法为抽象方法。

enum Direction {

    FRONT() {

        public void fun() {

            System.out.println("FROND：重写了fun()方法");

        }

    },

    BEHIND() {

        public void fun() {

            System.out.println("BEHIND：重写了fun()方法");

        }

    },

    LEFT() {

        public void fun() {

            System.out.println("LEFT：重写了fun()方法");

        }

    },

    RIGHT() {

        public void fun() {

            System.out.println("RIGHT：重写了fun()方法");

        }

    };

    public abstract void fun()[只需要把fun()方法修改为抽象方法，但不可以把Direction类声明为抽象类。];

}

7、每个枚举类都有两个特殊方法

每个枚举类都有两个不用声明就可以调用的static方法，而且这两个方法不是父类中的方法。这又是枚举类特殊的地方，下面是Direction类的特殊方法。

static Direction[] values()：返回本类所有枚举常量；

static Direction valueOf(String name)：通过枚举常量的名字返回Direction常量，注意，这个方法与Enum类中的valueOf()方法的参数个数不同。

十二、流

关键字

input 输入 output 输出 stream 流 writer 字符输入流 reader 字符输入流 File文件

只要会了字节流就都会了

字节流能处理一切

按输入输出分

按字节和字符分

节点流和处理流

十三、异常

1、checked 检查性异常

在编译的时候使用try,catch来预先捕获异常来提供解决方案

FileNotFoundException IoException InterruptedException

这种异常继承自Exception，必须捕获，并处理

2、运行时异常

去坐飞机，没带护照，这是你自己的原因，可以通过检查一下解决

ArrayIndexOutOfBoundsException ClassCastException 数学类异常

这种异常继承RuntimeException，不需要捕获，需要通过检查来预防。

3、错误 Error

stackOutOfMemoryError  比如递归出不去

4、自定义异常

很多时候我们需要自己定义一些异常来帮助我们来处理一些业务。

十四、算法

1、排序

选择排序

冒泡排序

插入排序

希尔排序

快速排序

归并排序

堆排序 大根堆 小根堆 完全二叉树

同排序

基数排序

计数排序

2、查找

二分查找

3、链表

数组和链表的区别：

数组按下标查找块，插入效率慢

链表查找慢，插入效率快

4、队列和栈

5、hash算法，可以将任何的文件转化成一个定长的字符串

hash碰撞：当两个文件生成的字符串一样了，就叫hash碰撞

5、递归

方法自己调用自己

一定要有出口，没有出口就会栈内存溢出；

案例：斐波那契数列

6、超级集合

十五、网络编程

1、概述

一、网络编程三要素

1、IP地址

要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识

2、端口

网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识

3、协议

通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的**规则**被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。**常见的协议有UDP协议和TCP协议**

二、IP地址

IP地址：是网络中设备的唯一标识

IP地址分为两大类

IPv4：是给每个连接在网络上的主机分配一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit，也就是4个字节。例如一个采用二进制形式的IP地址是“11000000 10101000 00000001 01000010”，这么长的地址，处理起来也太费劲了。为了方便使用，IP地址经常被写成十进制的形式，中间使用符号“.”分隔不同的字节。于是，上面的IP地址可以表示为“192.168.1.66”。IP地址的这种表示法叫做“点分十进制表示法”，这显然比1和0容易记忆得多

IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，这样就解决了网络地址资源数量不够的问题

DOS常用命令：

ipconfig：查看本机IP地址

ping IP地址：检查网络是否连通

特殊IP地址：

127.0.0.1：是回送地址，可以代表本机地址，一般用来测试使用

###

三、InetAddress

InetAddress：此类表示Internet协议（IP）地址

相关方法

方法名说明

static InetAddress getByName(String host)确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址

String getHostName()获取此IP地址的主机名

String getHostAddress()返回文本显示中的IP地址字符串

代码演示

public class InetAddressDemo {

    public static void main(String[] args) throws UnknownHostException {

//InetAddress address = InetAddress.getByName("itheima");

        InetAddress address = InetAddress.getByName("192.168.1.66");

        //public String getHostName()：获取此IP地址的主机名

        String name = address.getHostName();

        //public String getHostAddress()：返回文本显示中的IP地址字符串

        String ip = address.getHostAddress();

        System.out.println("主机名：" + name);

        System.out.println("IP地址：" + ip);

    }

}

###

四、端口和协议

端口

设备上应用程序的唯一标识

端口号

用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败

协议

计算机网络中，连接和通信的规则被称为网络通信协议

UDP协议

用户数据报协议(User Datagram Protocol)

UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。

由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输

例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议

TCP协议

传输控制协议 (Transmission Control Protocol)

TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”

三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠

第一次握手，客户端向服务器端发出连接请求，等待服务器确认

第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求

第三次握手，客户端再次向服务器端发送确认信息，确认连接

完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等

2、UDP

一、Java中的UDP通信

UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念

Java提供了DatagramSocket类作为基于UDP协议的Socket

二、发送数据

构造方法

方法名说明

DatagramSocket()创建数据报套接字并将其绑定到本机地址上的任何可用端口

DatagramPacket(byte[] buf,int len,InetAddress add,int port)创建数据包,发送长度为len的数据包到指定主机的指定端口

相关方法

方法名说明

void send(DatagramPacket p)发送数据报包

void close()关闭数据报套接字

void receive(DatagramPacket p)从此套接字接受数据报包

发送数据的步骤

创建发送端的Socket对象(DatagramSocket)

创建数据，并把数据打包

调用DatagramSocket对象的方法发送数据

关闭发送端

public class SendDemo {

    public static void main(String[] args) throws IOException {

        //创建发送端的Socket对象(DatagramSocket)

        // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口

        DatagramSocket ds = new DatagramSocket();

        //创建数据，并把数据打包

        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)

        //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。

        byte[] bys = "hello,udp,我来了".getBytes();

        DatagramPacket dp = new DatagramPacket(bys,bys.length,InetAddress.getByName("192.168.1.66"),10086);

        //调用DatagramSocket对象的方法发送数据

        //void send(DatagramPacket p) 从此套接字发送数据报包

        ds.send(dp);

        //关闭发送端

        //void close() 关闭此数据报套接字

        ds.close();

    }

}

三、接受数据

接收数据的步骤

创建接收端的Socket对象(DatagramSocket)

创建一个数据包，用于接收数据

调用DatagramSocket对象的方法接收数据

解析数据包，并把数据在控制台显示

关闭接收端

构造方法

方法名说明

DatagramPacket(byte[] buf, int len)创建一个DatagramPacket用于接收长度为len的数据包

相关方法

方法名说明

byte[]  getData()返回数据缓冲区

int  getLength()返回要发送的数据的长度或接收的数据的长度

示例代码

public class ReceiveDemo {

    public static void main(String[] args) throws IOException {

        //创建接收端的Socket对象(DatagramSocket)

        DatagramSocket ds = new DatagramSocket(12345);

        while (true) {

            //创建一个数据包，用于接收数据

            byte[] bys = new byte[1024];

            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            //调用DatagramSocket对象的方法接收数据

            ds.receive(dp);

            //解析数据包，并把数据在控制台显示

            System.out.println("数据是：" + new String(dp.getData(), 0,                                            dp.getLength()));

        }

    }

}

3、TCP

一、Java中的TCP通信

Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。

Java为客户端提供了Socket类，为服务器端提供了ServerSocket类

二、发送数据

构造方法

方法名说明

Socket(InetAddress address,int port)创建流套接字并将其连接到指定IP指定端口号

Socket(String host, int port)创建流套接字并将其连接到指定主机上的指定端口号

相关方法

方法名说明

InputStream  getInputStream()返回此套接字的输入流

OutputStream getOutputStream()返回此套接字的输出流

示例代码

public class ClientDemo {

    public static void main(String[] args) throws IOException {

        //创建客户端的Socket对象(Socket)

        //Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号

        Socket s = new Socket("192.168.1.66",10000);

        //获取输出流，写数据

        //OutputStream getOutputStream() 返回此套接字的输出流

        OutputStream os = s.getOutputStream();

        os.write("hello,tcp,我来了".getBytes());

        //释放资源

        s.close();

    }

}

三、接收数据

构造方法

方法名说明

ServletSocket(int port)创建绑定到指定端口的服务器套接字

相关方法

方法名说明

Socket accept()监听要连接到此的套接字并接受它

示例代码

public class ServerDemo {

    public static void main(String[] args) throws IOException {

        //创建服务器端的Socket对象(ServerSocket)

        //ServerSocket(int port) 创建绑定到指定端口的服务器套接字

        ServerSocket ss = new ServerSocket(10000);

        //Socket accept() 侦听要连接到此套接字并接受它

        Socket s = ss.accept();

        //获取输入流，读数据，并把数据显示在控制台

        InputStream is = s.getInputStream();

        byte[] bys = new byte[1024];

        int len = is.read(bys);

        String data = new String(bys,0,len);

        System.out.println("数据是：" + data);

        //释放资源

        s.close();

        ss.close();

    }

}

十六、JDK新特性

1、Lambda表达式

1.1、Lambda表达式的使用前提

使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法

必须有上下文环境，才能推导出Lambda对应的接口

根据局部变量的赋值得知Lambda对应的接口

Runnable r = () -> System.out.println("Lambda表达式");

根据调用方法的参数得知Lambda对应的接口

new Thread(() -> System.out.println("Lambda表达式")).start();

1.2、Lambda表达式的标准格式

格式：

(形式参数) -> {代码块}

形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

->：由英文中画线和大于符号组成，固定写法。代表指向动作

代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

组成Lambda表达式的三要素：

形式参数，箭头，代码块

代码演示：

//方式一的线程类

public class MyRunnable implements Runnable {

    @Override

    public void run() {

        System.out.println("多线程程序启动了");

    }

}

public class LambdaDemo {

    public static void main(String[] args) {

        //方式一

//        MyRunnable my = new MyRunnable();

//        Thread t = new Thread(my);

//        t.start();

        //方式二

//        new Thread(new Runnable() {

//            @Override

//            public void run() {

//                System.out.println("多线程程序启动了");

//            }

//        }).start();

        //方式三

        new Thread( () -> {

            System.out.println("多线程程序启动了");

        } ).start();

    }

}

1.3Lambda表达式和匿名内部类的区别

所需类型不同

匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

Lambda表达式：只能是接口

使用限制不同

如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同

匿名内部类：编译之后，产生一个单独的.class字节码文件

Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

2、接口

2.1接口中默认方法

格式

public default 返回值类型 方法名(参数列表) {  }

范例

public default void show3() {

}

注意事项

默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字

public可以省略，default不能省略

2.2接口中静态方法

格式

public static 返回值类型 方法名(参数列表) {  }

范例

public static void show() {

}

注意事项

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用

public可以省略，static不能省略

2.3接口中私有方法

私有方法产生原因

Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性

定义格式

格式1

private 返回值类型 方法名(参数列表) {  }

范例1

private void show() { 

}

格式2

private static 返回值类型 方法名(参数列表) {  }

范例2

private static void method() { 

}

注意事项

默认方法可以调用私有的静态方法和非静态方法

静态方法只能调用私有的静态方法

3、方法引用

你可能感兴趣的:(Javase基础)

  • JavaSE基础学习day3--异常&&集合 yz不摆烂24124 学习java
    目录1.异常1.1异常概述1.2JVM的默认处理方案1.3异常处理1.4异常处理之try...catch...1.5Throwable的成员方法1.6编译时异常和运行时异常的区别1.7异常处理之throws1.8自定义异常1.9throws和throw的区别throwsthrow2.集合引入3.Collection3.1Collection的概述3.2Collection集合使用方法3.3集合的遍
  • javaSE基础知识点（部分） 乖，别闹596 java算法数据结构
    1、基本类型和引用类型的区别？基本数据类型在被创建时，在栈上给其划分一块内存，将数值直接存储在栈（Stack）上。​引用数据类型在被创建时，首先要在栈上给其引用分配一块内存，而对象的具体信息都存储在堆内存上，然后由栈（Stack）上面的引用指向堆（Heap）中对象的地址。【引用(栈)——>对象地址(堆)】​​2、快速排序快速排序是一种高效的排序算法，其基本思想是采用分治策略。​快速排序算法通过多次
  • 社会(逻辑)的本质,层(方法和类) 庖丁解java java系统架构
    从javaSE,到中间件,再到系统间对接,我本觉得逻辑已经完备,以后的工作就是慢慢填补细节,直到把整个java语言,彻底解析清除.从而使得工作能够变得游刃有余,最后再公司混个架构师当当...哈哈,想得有点远了.后来越看越不对,因为我在想javaSE的时候,发现一个东西,就是utils(工具类)这个东西,似乎不太属于javaSE基础内容.但你说他属于业务内容吧,也不太对.但一回想我的具体工作,发现u
  • Java SE基础——Java集合 原来是帅亮亮呀 java
    JavaSE基础——Java集合Java集合框架概述Java容器：集合与数组(1)面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。集合，数组都是对多个数据进行存储操作的结构说明：此时的存储，主要指的是内存的存储，不涉及到持久化的存储（.txt,.jpg,.avi,数据库中）(2)数组在存储多个数据方面的特点：一旦初始化以后，其长度就确定了。数组一旦定义好，其
  • 软通动力华为java机考题库_软通动力Java考试题库.doc 假行酥 软通动力华为java机考题库
    软通动力Java考试题库.doc软通动力培训课程题库Java编号：ISS-TJ-TC版本：1.0作者：JavaSE基础康佳琪日期作者：JavaEE高级张建军日期：审批人：张林福日期：目录JavaSE基础部分Java基础Java面向对象Java异常Java集合框架J2EE中，下列不属于集合类的是()。(选择一项)CVectorStackEnumerationHashtable2)在J2EE中，下列元
  • 学习记录(自用) weixin_33962621 java大数据数据库
    Java学习路径及记录，纯粹个人自用，请多指教JavaJava基础常用类常用类8种基础数据类型的包装类自动打包/解包序列化深入理解Java序列化深度解析JAVA序列化异常处理JavaSE基础:异常处理六个例子彻底理解finally语句块JVM原理Java高级特性泛型Java泛型详解细说Java泛型及其应用细说Java泛型及其应用反射注解Java注解完全解析Java网络编程Java多线程编程线程基础
  • JavaSE基础知识总结（上） 北纬40度~ 笔记java程序设计
    作为一名程序设计人员，常常希望能够有一种语言，它具有令人赏心悦目的语法和利于理解的语义Java白皮书关键术语简单性面向对象分布式健壮性安全性体系结构中立可移植性解释型高性能多线程动态性1、使用命令行工具编译javacHelloWorld.javajavaHelloWorldjavac程序是一个java编译器，他将文件HelloWorld.java文件编译成HelloWorld.class。java
  • 大数据系列教程003-hadoop伪分布式环境搭建步骤 Java潘老师 大数据系列教程大数据hadoop伪分布式环境搭建
    声明：大数据系列教程文章由Java潘老师辛苦原创，免费公开供java爱好者学习。如需转载请获得潘老师授权并保留原文链接，如有疑问或建议，可以联系潘老师：Q：1562691348V：A1562691348本教程学习知识储备：JavaSE基础、Linux基础、数据库基础步骤：直接点击链接查看1.安装vmware122.设置vmware虚拟网络编辑器3.安装虚拟机CentOS74.设置静态ip5.永久修
  • Java基础学习笔记：基本语法篇 千山暮景 java编程语言jdk数据类型
    JavaSE基础JDK、JRE、JVMJDK(JavaDevelopmentKit)：是Java语言的软件开发工具包(SDK)。JRE（JavaRuntimeEnvironment，Java运行环境），包含JVM标准实现及Java核心类库。JVM是JavaVirtualMachine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各
  • JavaSE基础学习笔记懒人简略版 sunyunfei1994 java
    001java基础入门一Java介绍1,java历史Java,1995年sun公司詹姆斯.高斯林计算机高级编程语言2009年被甲骨文Oracle公司收购2,Java三大技术体系JavaSE(标准版):java技术核心和基础(直观桌面应用)JavaEE(企业版):企业级应用开发JavaME(小型版):移动设备应用(已经被安卓与苹果系统取代)二Java入门1,JDKJDK(全称JavaDevelopm
  • JavaSE基础——数组概述和定义格式说明 ZHBlog_ JavaSE学习数组递归菲波那切数列杨辉三角
    JAVA学习day05javase基础语法——数组概述和定义格式说明1.1数组的概念数组是存储同一种数据类型多个元素的集合。也可以看成一个容器。数组既可以存储基本数据类型，也可以存储引用数据类型，但在同一个数组中，存储的数据类型必须一致。定义格式：数据类型[]数组名=new数据类型[元素个数或数组长度]；或数据类型数组名[]=new数据类型[元素个数或数组长度]；int[]arr=newint[2
  • 黑马程序员——javase基础——day08——数组 阿瞒有我良计15 #JavaSE数据结构
    目录：一维数组数组概述和课程安排数组定义和静态初始化数组元素访问(获取和修改)案例1(数组常见操作之遍历)案例2(数组常见操作之获取最大值)案例3(数组常见操作之元素打乱)数组动态初始化案例4(数组元来自键盘录入)数组内存图数组使用中的两个小问题二维数组二维数组概述和课程安排二维数组初始化二维数组元素访问二维数组内存图案例5(二维数组常见操作之遍历)案例6(二维数组常见操作之元素打乱)案例7(图片
  • Java面试题-JavaSE基础1 杨家小少爷 Java面试题JavaSE基础Java面试题面试题
    一、Java面向对象面向对象都有哪些特性以及你对这些特性的理解1）继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。2）封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成
  • JavaSE基础学习 程序员的人生K Java学习java
    一、编程入门二、Java语言概述三、Java基本语法四、程序流程控制五、数组六、面向对象(上)数组工具类的封装:七、面向对象(中)八、面向对象(下)九、异常处理十、多线程十一、常用类十二、枚举类与注解十三、集合十四、泛型十五、IO流十六、网络编程十七、反射与动态代理十八、Java8新特性十九、Java9&10&11新特性
  • JavaSE基础学习——注解 KnightZer0 javaidea
    1.注解概述Java注解（Annotation）又称Java标注，是JDK5.0引入的一种注释机制。Java语言中的类、构造器、方法、成员变量、参数等都可以被注解进行标注。注解作用对Java中类、方法、成员变量做标记，然后进行特殊处理，至于到底做何种处理由业务需求来决定。2.自定义注解特殊属性value属性，如果只有一个value属性的情况下，使用value属性的时候可以省略value名称不写但是
  • javaSE基础学习计划 竹篮打水碎又圆 javastruts算法
    Java基础语法（已完成）流程控制与方法（已完成）面向对象数组集合异常处理常用类IO知识点的了解应该每天更新总体来说计划15天左右就要熟悉基础的知识并应用。
  • 2020 javaSE基础学习视频 你加班的bug是我写的 java编程语言
    2020值得学习的javaSE基础学习视频从最基本的概念开始讲起，步步深入，从HelloWorld开始，通过一步步动手实践，最终完成一个简单又实用的案例，不仅用上之前的所有知识，还可以应用在未来的学习生活中。视频是尚硅谷老师辛苦制作。感谢！网盘连接：链接：https://pan.baidu.com/s/13AQuHcIU_ZxS8qn6DLSSUA提取码：w52s资料源码笔记：链接：https:/
  • JavaSE基础系列之设计模式必备基础 l烈阳l JavaSE基础系列
    作为开发人员，设计模式大家肯定都知道它的重要性，不论在业务系统的架构设计上，还是在技术框架的底层都有许多应用。设计模式是开发人员的基本功，学好设计模式对自己技术生涯，尤为重要。要想把设计模式搞透，除了大量的业务场景帮助理解。另外理解设计原则是重中之中，一切模式都是基于设计原则而来的。一.设计模式常用的原则单一职责原则对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当
  • Javase基础语法 新起之猿 java开发语言
    Javase基础语法IDE的使用（是所以开发工具的总称)集成开发环境用于提供程序开发环境的应用程序一般包括编辑器，编译器，调试器，图形用户界面等常用的开发工具intellijideaeclipse注释对代码功能说明//单行注释Ctrl+//**/多行注释Ctrl+shift+/反之Ctrl+shift+\/***/文档注释，用于为类，成员变量，方法等进行注释可以在其他地方提示关键字特定的单词来修饰
  • Javase基础5：数组、数组查找、排序、二维数组 疯丰 大数据之javase基础java开发语言
    目录1.笔记1.1数组2.练习2.1二维数组练习题2.2二维数组的内存图分析(重要)1.笔记1.1数组1.数组容器：存储东西(数据)的数组概念：数组就是用于存储数据的长度固定的容器，保证多个数据的数据类型要一致①创建数组的时候，必须指定长度②数组在创建的时候，需要指定数据类型③数组是有顺序的(位置的顺序)数组的特点：数组的长度一旦确定，就不允许修改2.数组的使用2.1数组的定义①动态初始化★语法：
  • JavaSE基础语法--傻瓜笔记--1031(第四章:数组与基础排序算法) 袁永豪 笔记java数组排序算法
    第四章：数组1.数组的基本概念及作用定义：数组是相同数据类型元素的集合。数组本身是引用数据类型，即对象。但是数组可以存储基本数据类型，也可以存储引用数据类型。数组是一种线性数据结构，在内存中是连续空间。2.数组的创建数组声明的两种形式：数据类型[]数组名例：int[]a;数据类型数组名[]例：inta[];注：在java中两种声明格式没有任何区别，但是建议大家使用第一种，避免混淆a的数据类型。特例
  • 黑马程序员——javase基础——day09——动漫美女拼图 阿瞒有我良计15 #JavaSE美女
    目录：继承继承概述继承的练习动漫美女拼图项目演示和课程安排动漫美女拼图游戏实现窗体绘制窗体上组件绘制图片打乱纪录0号图片的索引给按钮注册事件移动业务实现上移业务实现其他移动业务实现求助业务实现移动业务的问题重置业务实现1.继承继承概述来，继续啊，为了讲解项目动漫拼图，这里我们先讲解一个小知识：继承概述。通过这个名字呢，大家也发现了，这里我们仅仅是对继承做一个简单的讲解，后续呢，会深入的给大家再来讲
  • 【JavaSE基础】多态 Sampson_S JavaSE基础
    Java面向对象特征：封装、继承、多态多态多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作。多态性是对象多种表现形式的体现。多态的优点：消除类型之间的耦合关系可替换性可扩充性接口性灵活性简化性多态存在的三个必要条件继承重写父类引用指向子类对象Parentp=newChild();多态主要分为两种：编译期多态和运行期多态。编译期多态：又称：静多态，静
  • 黑马程序员——javase基础——day01——Java入门&IDEA&基础语法 阿瞒有我良计15 #JavaSEintellij-ideajavaide
    目录：Java入门Java简介JDK的下载和安装第一个程序常见问题常用DOS命令Path环境变量IDEAIDEA概述和安装IDEA中HelloWorldIDEA中基本配置&注释IDEA中常用快捷键IDEA中模块操作基础语法字面量数据类型变量变量的案例手机信息描述疫情防控信息采集表变量的注意事项关键字标识符1.Java入门Java简介下面我们正式进入Java的学习，在这里，大家第一个关心的问题，应该
  • 黑马程序员——javase基础——day04——方法 阿瞒有我良计15 #JavaSE前端
    目录：方法的定义和使用方法概述和课程安排方法的定义和调用Debug查看方法调用练习1(输出较大值)带参数方法的定义和调用形参和实参练习2(输出较大值)带返回值方法的定义和调用练习3(输出较大值)方法的注意事项方法的通用格式方法通用格式练习1(求和)练习2(比较相等)练习3(较大值)练习4(水仙花)方法重载方法重载练习(比较相等)1.方法的定义和使用方法概述和课程安排来，继续啊，下面我们来学习Jav
  • 黑马程序员——javase基础——day03——循环语句 阿瞒有我良计15 #JavaSEjavaandroid开发语言
    目录：for循环结构for循环结构案例1(输出数据)案例2(求和思想)案例3(求偶数和)案例4(水仙花数)案例5(统计思想)案例6(回文数)案例7(逢七过)while循环结构while循环结构案例1(求奇数和)案例2(珠穆朗玛峰)do-while循环结构do-while循环结构三种循环的区别continue和breakcontinue和break综合案例(小芳存钱)1.for循环结构for循环结构
  • 黑马程序员——javase基础——day02——运算符&选择语句 阿瞒有我良计15 #JavaSEpythonjava
    目录：运算符算术运算符案例数值拆分+操作的三种情况数字相加(类型转换)字符相加字符串相加赋值运算符选择语句顺序结构Debug的基本使用选择语句之ifif语句格式1if语句格式2和格式3案例1(交通信号灯)关系运算符案例2(奇偶数)案例3(手机以旧换新)案例4(你是青年人吗)逻辑运算符三元运算符和if语句格式2的区别选择语句之switch1.运算符前面我们学过了通过字面量和变量来表示一个数据，这里呢
  • 【JavaSe语法】详解封装、继承、多态 careathers java开发语言
    图片出处：Theworld'sbiggestdronephotoandvideosharingplatform|SkyPixel.com前言封装、继承、多态等是面向对象程序三大特性，也是JavaSe基础语法中较难的部分。在本文之我会结合所学的知识与自己的理解向大家阐明这三种特性的概念及运用。目录前言封装1，封装的概念2，封装的实现继承1，继承的概念2，继承的语法3，父类成员的访问4，super关键
  • JavaSE基础之多态中成员的访问 CL_Ray
    当一个父类引用持有子类对象时，对于成员（变量及方法）的访问是有不同的，具体如下：publicclassMainClass{publicstaticvoidmain(String[]args){Fatherf=newChild();System.out.println(f.num);f.hello();}}publicclassFather{intnum=10;publicvoidhello(){S
  • 【JavaSE基础】02-面向对象 老坛算粉 JavaSE2EEjava
    原文写于2016年，个人学习笔记，闲来无事，搬运至此，希望于各位有用。主要内容是：面向对象的基础概念、三大特性、链式编程等。当年真的好有毅力，一字一字敲，一图一图画。文章目录面向对象(Object-OrientedProgramming)1、面向对象概念2、面向对象特点3、面向对象开发、设计、`特征`4、类（与对象）5、类的内存图解`6、成员变量和局部变量的区别`7、形式参数8、匿名对象9、三大特
  • rust的指针作为函数返回值是直接传递，还是先销毁后创建？ wudixiaotie 返回值
     这是我自己想到的问题，结果去知呼提问，还没等别人回答， 我自己就想到方法实验了。。 fn main() { let mut a = 34; println!("a's addr:{:p}", &a); let p = &mut a; println!("p's addr:{:p}", &a
  • java编程思想 -- 数据的初始化 百合不是茶 java数据的初始化
      1.使用构造器确保数据初始化      /* *在ReckInitDemo类中创建Reck的对象 */ public class ReckInitDemo { public static void main(String[] args) { //创建Reck对象 new Reck(); } }
  • [航天与宇宙]为什么发射和回收航天器有档期 comsci
           地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁...        所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 &
  • linux下批量替换文件内容 商人shang linux替换
    1、网络上现成的资料 　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 　　linux sed 批量替换多个文件中的字符串 　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 　　例如：替换/home下所有文件中的www.admi
  • 网页在线天气预报 oloz 天气预报
    网页在线调用天气预报 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
  • SpringMVC和Struts2比较 杨白白 springMVC
    1. 入口 spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。 参见：http://blog.csdn.net/zs15932616453/article/details/8832343 2
  • refuse copy, lazy girl! 小桔子 copy
           妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 1.那是我自己觉得写不出的高度 2.如果直接拿来用，很快就能解决问题 3.然后就是抄咩~~ 4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！  
  • apache与php整合 aichenglong php apache web
    一  apache web服务器 1 apeche web服务器的安装   1)下载Apache web服务器   2)配置域名(如果需要使用要在DNS上注册)   3)测试安装访问http://localhost/验证是否安装成功 2 apache管理   1)service.msc进行图形化管理   2)命令管理，配
  • Maven常用内置变量 AILIKES maven
    Built-in properties ${basedir} represents the directory containing pom.xml ${version} equivalent to ${project.version} (deprecated: ${pom.version}) Pom/Project properties Al
  • java的类和对象 百合不是茶 JAVA面向对象 类 对象
    java中的类：     java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决   java使用 class 类名   来创建类 ，在Java中类名要求和构造方法，Java的文件名是一样的   创建一个A类： class A{ }   java中的类：将某两个事物有联系的属性包装在一个类中，再通
  • JS控制页面输入框为只读 bijian1013 JavaScript
    在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。  
  • AngularJS与服务器交互 bijian1013 JavaScriptAngularJS$http
            对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： var xmlhttp = new XMLHttpRequest(); xmlhttp.onreadystatechange
  • [Maven学习笔记八]Maven常用插件应用 bit1129 maven
    常用插件及其用法位于：http://maven.apache.org/plugins/   1. Jetty server plugin 2. Dependency copy plugin 3. Surefire Test plugin 4. Uber jar plugin           1. Jetty Pl
  • 【Hive六】Hive用户自定义函数(UDF) bit1129 自定义函数
    1. 什么是Hive UDF Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括： 文件格式：Text File，Sequence File 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 用户提供的 map/reduce 脚本：不管什么
  • 杀掉nginx进程后丢失nginx.pid，如何重新启动nginx ronin47 nginx 重启 pid丢失
    nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
  • UI设计中我们为什么需要设计动效 brotherlamp UIui教程ui视频ui资料ui自学
    随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。 但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。 一、加强体验舒适度 嗯，就是让用户更加爽更加爽的用你的产品。
  • Spring中JdbcDaoSupport的DataSource注入问题 bylijinnan javaspring
    参考以下两篇文章： http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration Sprin
  • 数据库连接池的工作原理 chicony 数据库连接池
           随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动 态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查 询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
  • java 关键字 CrazyMizzz java
    关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 Java中的关键字按功能主要可以分为以下几类：    （1）访问修饰符       public,private,protected       p
  • Hive中的排序语法 daizj 排序hiveorder byDISTRIBUTE BYsort by
    Hive中的排序语法 2014.06.22 ORDER BY hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。 与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
  • 单态设计模式 dcj3sjt126com 设计模式
      单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。 使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。 <?phpclass Example{    // 保存类实例在此属性中    private static&
  • svn locked dcj3sjt126com Lock
    post-commit hook failed (exit code 1) with output: svn: E155004: Working copy 'D:\xx\xxx' locked svn: E200031: sqlite: attempt to write a readonly database svn: E200031: sqlite: attempt to write a
  • ARM寄存器学习 e200702084 数据结构C++cC#F#
    无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。     ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 1、不分组寄存器（R0-R7）     不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
  • 常用编码资料 gengzg 编码
    List<UserInfo> list=GetUserS.GetUserList(11); String json=JSON.toJSONString(list); HashMap<Object,Object> hs=new HashMap<Object, Object>(); for(int i=0;i<10;i++) {
  • 进程 vs. 线程 hongtoushizi 线程linux进程
    我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。 首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。 如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。 如果用多线程实现
  • Linux定时Job：crontab -e 与 /etc/crontab 的区别 Josh_Persistence linuxcrontab
    一、linux中的crotab中的指定的时间只有5个部分：* * * * * 分别表示：分钟，小时，日，月，星期，具体说来： 第一段 代表分钟 0—59 第二段 代表小时 0—23 第三段 代表日期 1—31 第四段 代表月份 1—12 第五段 代表星期几，0代表星期日 0—6   如： */1 * * * *   每分钟执行一次。 *
  • KMP算法详解 hm4123660 数据结构C++算法字符串KMP
         字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。       假设主串s="ababcabcacbab",模式串为t="
  • 枚举类型的单例模式 zhb8015 单例模式
    E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
  • Kafka+Storm+HDFS ssydxa219 storm
    cd /myhome/usr/stormbin/storm nimbus &amp;bin/storm supervisor &amp;bin/storm ui &amp;Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
  • Java获取本地服务器的IP 中华好儿孙 javaWeb获取服务器ip地址
    System.out.println("getRequestURL:"+request.getRequestURL()); System.out.println("getLocalAddr:"+request.getLocalAddr()); System.out.println("getLocalPort:&quo