java service1(基础)

最新推荐文章于 2024-01-25 20:37:12 发布

置顶 georgehenrywilliam

最新推荐文章于 2024-01-25 20:37:12 发布

阅读量1.1k

点赞数

本文链接：https://blog.csdn.net/georgehenrywilliam/article/details/62045650

版权

http://m.bjsxt.com/download.html//马士兵教程

http://blog.csdn.net/allinornothing/article/details/46505245

//看到这个文章不错，各位想转服务器的可以看看

http://www.cnblogs.com/jycboy/p/6227193.html

http://blog.csdn.net/ld0807/article/details/61915006?v=6

http://blog.csdn.net/feng2qing/article/details/60968548

//Spring框架环境配置

http://blog.csdn.net/Love_Beauty/article/details/53611422

http://blog.csdn.net/dreamcatchergo/article/details/8108467

http://www.roncoo.com/article/detail/129525

https://blog.csdn.net/javazejian/article/list/1

https://blog.csdn.net/javazejian/article/details/72772461

java 代理

https://blog.csdn.net/u010486679/article/details/80980371

//一直想学习javaEE但是oracle下载下来之后居然是glassFish，都说EE爱吃鱼，一直不懂为什么我要的是javaEE的jdk为什么给我一个glassfish,终于明白了,glassFish其实包含了javaEE所需要的jar,但是国内的话一般都使用tomcat,具体的区别的话，我认为,glassFish属于学院派,tomcat属于实战派。

＊java的一些配置，首先Eclipse下载，tomcat下载并安装集成到eclipse,但是由于我是新手两天才搞出来，还是看到了一个博客才联想到的，主要是路径要对，安装这些都好说，所有的都要求细心，，部署静态网页的话放在webapps/root下面，链接路径要显示后缀。eclipse集成tomcat要在tomcat9.0下而不是其他目录下,配置好之后在我公司的局域网下可以使用但是一到外网就不行了，后来问了服务器开发人员说是没有静态IP＊

1：设计理念区别
抽象类：被继承体现的是：”is a”的关系。在抽象类中定义的一般是共性功能
接口：被实现体现的是：”like a”的关系。在接口中定义的一般是扩展功能

2.接口中的所有方法均为抽象方法，抽象类中包含非抽象方法和抽象方法。如果一个类实现了接口，那么该子类必须实现父接口的所有方法。如果一个类继承了抽象类，那么该子类必须实现抽象类的所有抽象方法。

/**匿名内部类**/

3.只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现

最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口

String 字符串常量
StringBuffer 字符串变量（线程安全）
StringBuilder 字符串变量（非线程安全）

为什么会有泛型呢?

通过案例引入
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
- 泛型类
- 把泛型定义在类上
- 格式:public class类名<泛型类型1,…>
- 注意:泛型类型必须是引用类型
- 泛型方法
- 把泛型定义在方法上
- 格式:public <泛型类型>返回类型方法名(泛型类型.)
- 泛型接口
- 把泛型定义在接口上
- 格式:public interface接口名<泛型类型1…>

5.数据结构/java数据结构

(1):线性结构：数据结构中的元素存在一对一的相互关系

(2):树形结构：数据结构中的元素存在一对多的相互关系

(3):图形结构:数据结构中的元素存在多对多的相互关系

线性表是最简单、最基本、也是最常用的一种线性结构。线性表是具有相同数据类型n(n>=0)个数据元素的有限序列，通常记为： (a1，a2，… ai-1，ai，ai+1，…an) ，其中n为表长， n=0 时称为空表。它有两种存储方法：顺序存储和链式存储，它的主要基本操作是插入、删除和检索等。

java

Collection接口概述

Collection 层次结构中的根接口。Collection表示一组对象，这些对象也称为collection的元素。一些collection允许有重复的元素，而另一些则不允许。一些collection是有序的，而另一些则是无序的。

Iterator接口概述

对 collection进行迭代的迭代器
依赖于集合而存在

- Vector类概述
- 底层数据结构是数组，查询快，增删慢
- 线程安全，效率低
- Vector类特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements()
- Vector案例
- 存储字符串并遍历
- 存储自定义对象并遍历
ArrayList类概述

底层数据结构是数组，查询快，增删慢
线程不安全，效率高

ArrayList案例

存储字符串并遍历
存储自定义对象并遍历

LinkedList类概述

底层数据结构是链表，查询慢，增删快
线程不安全，效率高

LinkedList类特有功能

public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()

LinkedList案例

存储字符串并遍历
存储自定义对象并遍历

HashSet类概述

不保证 set的迭代顺序
特别是它不保证该顺序恒久不变。

HashSet如何保证元素唯一性

底层数据结构是哈希表(元素是链表的数组)
哈希表依赖于哈希值存储
添加功能底层依赖两个方法：
- int hashCode()
- boolean equals(Object obj)

LinkedHashSet类概述

元素有序唯一
由链表保证元素有序
由哈希表保证元素唯一

TreeSet类概述

使用元素的自然顺序对元素进行排序
或者根据创建 set时提供的Comparator进行排序
具体取决于使用的构造方法。

TreeSet是如何保证元素的排序和唯一性的

底层数据结构是红黑树(红黑树是一种自平衡的二叉树)

Collection

List
- ArrayList
- Vector
- LinkedList
Set
- HashSet
- TreeSet

Map接口概述

将键映射到值的对象
一个映射不能包含重复的键
每个键最多只能映射到一个值

Map接口和Collection接口的不同

Map是双列的,Collection是单列的
Map的键唯一,Collection的子体系Set是唯一的
Map集合的数据结构值针对键有效，跟值无关

Collection集合的数据结构是针对元素有效

HashMap

LinkedHashMap

TreeMap

Java Thread 线程

Java中的多线程是一种抢占机制而不是分时机制。抢占机制指的是有多个线程处于可运行状态，但是只允许一个线程在运行，他们通过竞争的方式抢占CPU。

System.out.println(e)，这个方法打印出异常，并且输出在哪里出现的异常，不过它和另外一个e.printStackTrace()方法不同。后者也是打印出异常，但是它还将显示出更深的调用信息。

先敲“/”在敲两个**，然后回车,快速注释

java 中关于set()和fet()方法的理解和使用

我们先来看看set和get这两个词的表面意思,set是设置的意思，而get是获取的意思,顾名思义，这两个方法是对数据进行设置和获取用的。而且，在类中使用set和get方法时,都是set和get后面跟上一些特定的词来形成特定意思的方法名，比如setage()和getage(),表示设置年龄和获取年龄。

然后我们来了解一下java面向对象编程中的封闭性和安全性。封闭性即对类中的域变量进行封闭操作，即用private来修饰他们，如此一来其他类则不能对改变量访问。这样我们就将这些变量封闭在了类内部，这样就提高了数据的安全性，当我们想要操作这些域变量怎么办呢?我们可以通过两种方法，第一种即通过public方式的构造器(或称构造函数)，对象一实例化就对该变量赋值。第二种就是通过上面提到的set和get()方法，这里我举一个特定的例子，我定义一个person类,该类中有name,age这两个私有域变量，然后我定义setname()、getname()、setage()、getage()这四个方法，通过这四个方法来实现对name和age的操作。这样一来,我不用直接对person类中的域变量操作，而是通过set和get方法间接地操作这些变量,这样就能提高域变量的安全性，同时又保证了域变量的封装型。

最后说说set和get方法的使用场景，一般来说set和get方法都是对私有域变量进行操作的，所以大多数都是使用在包含特定属性的类实体中。

现在你明白set和get方法了吧，其实这两个方法只是类中的set和get方法的总称。

在今后的开发过程中，只要你细心体会，结合java中的一些宏观的知识。set和get方法还是容易理解的，或许你还会领会一些其他的JAVA中的重要理论知识

java 中的import机制(指定import和import*的区别)

java 中有两种包的导入机制，总结如下

单类型导入(single-type-import),例如import java.io.File;

按需类型导入(type-import-on-demand),例如 import java.io.*;

单类型导入比较好理解，仅仅导入一个public 类或者接口。

对于按需类型导入，有人误解为导入一个包下的所有类，其实不然，看名字就知道，他只会按需导入，也就是说它并非导入整个包，而仅仅导入当前类需要使用的类。

既然如此是不是就可以放心的使用按需类型导入呢？非也，非也。

因为单类型导入和按需类型导入对类文件的定位算法是不一样的。java编译器会从启动目录(bootstrap),扩展目录(extension)和用户类路径下去定位需要导入的类，而这些目录仅仅是给出了类的顶层目录。编译器的类文件定位方法大致可以理解为如下公式:

顶层路径名\包名\文件名.class =绝对路径

对于单类型导入很简单，因为包名和文件名都已经确定，所以可以一次性查找定位。对于按需类导入则比就复杂，编译器会把包名和文件名进入排列组合

然后对所有的可能性进行类文件查找定位.

例如：

package com;

import java.io.*;

import java.util.*;

当你的类文件中用到了File类，那么可能出现File类的地方如下

File \\ File类属于无名包，就是说File类没有package语句，编译器会首先搜索无名包

com.File \\ File类属于当前包

java.lang.File \\ 编译器会自动导入java.lang包

java.io.File

java.util.File

需要注意的地方就是，编译器找到java.io.File类之后并不会停止下一步的寻找，而要把所有的可能性都查找完以确定是否有类导入冲突。假设此时的顶层路径有三个，那么编译器就会进行3*5=15次查找。

注意：如果在查找完成后，编译器发现了两个同名的类，那么就会报错。要删除你不用的那个类，然后再编译。

了解以上原理之后，我们可以得出这样的结论：按需类型导入是绝对不会降低Java代码的执行效率的，但会影响到Java代码的编译速度。

查看JDK的源代码就知道SUN的软件工程师一般不会使用按需类型导入。因为使用单类型导入至少有以下两点好处：

1。提高编译速度。

2。避免命名冲突。（例如：当你import java.awt.*;import java.util.*后，使用List的时候编译器将会出编译错误）

当然，使用单类型导入会使用你的import语句看起来很长。

在Java诞生初期，垃圾回收是Java最大的亮点之一，因为服务器端的编程需要有效的防止内存泄露问题，然而时过境迁，如今Java的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS的系统比Android系统有更好的用户体验，其中一个深层次的原因就在于android系统中垃圾回收的不可预知性。

jvm回收

http://geek.csdn.net/news/detail/236894

java多线程

https://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ==&mid=2247483698&idx=1&sn=2cc8da03472d6c2a796312bf04680058&chksm=ebd63e1edca1b7084fdbb118570445aab00ad7a079c261c6c5d5088a6cefb4cb2748cc2474b4&scene=0#rd

文档注释/**然后回车。

java 变量必须赋初始值，如果不赋初始值的话打印会出错。虽然默认初始值为0，并且float,double,long后面加上f,d,l以保证精度,每一个字符都对应一个ASCII码，在字符参与到运算时是用ASCII 码，在字符参与运算时是用ASCII码参与到运算中的

a=20;a/-5,a%=5,a-=5.a+=5;

//网上视频课程记录

位运算符

<< 无符号左移，>>右移，>>>无符号右移,& | ^

在计算机中参与计算的都是二进制的数据，二进制数据分为原码，反码，补码，运算的时候都是用补码来运算。

0000 0101

1111 1101

<<将参与运算的二进制数据向左移动，在低位产生的空位用0来做补齐

>>将参与运算的二进制数据向右移动，在低位产生的空位如果高位是0，那么用0来做补齐，如果高位是1就用1来补齐,也就是说右移是带着符号位移动。

>>>无符号右移，将参与运算的数据向右移动，在高位所产生的空位0补齐

&运算不仅可以作为逻辑运算符，还可以做与运算。0相当于false 1相当于true,只有1和1&（与逻辑运算）计算的时候结果是1，其余都是0.

|（或逻辑运算）运算只有都是0的时候才是0否则都是1。

^异或计算 ^不仅可以作为逻辑运算符，还可以做与运算，如果计算的两个数相同就是0，不同就是1。

判断逻辑

break 跳出循环

continue 在某次循环的时候放弃，后续的接着循环。

在jdk1.7之前,switch 的表达式只能是byte,short,char,int,但是1.7后可以使用String,switch 使用break来跳出判断语句，如果不使用break的话表示穿透执行.

switch 只能做等值判断不能做区间判断

三元运算符

语法:表达式1 关系运算符表达式2？表达式3:表达式4。

三元运算符适合两个值的判断

函数

语法：<public> <static> 返回值类型[void] 方法名([数据类型变量名]...){

方法体

[return 返回结果值]} 方法是定义在类里面的。

数组

数组定义的第一种方式

语法数据类型[] 数组名 = new 数据类型[整数]

数组定义的第二种方式

语法数据类型[] 数组变量名 = {值1，值2,...};

数组定义的第三种方式

语法数据类型[] 数组变量名 = new 数据类型[]{值1，值2...}

数组求最大值

if(array!=null&&array.length!=0) {
       int max = array[0];
       for (int i = 1; i < array.length; i++) {
          max = max>array[i]?max:array[i];
       }

其实面向对象的语言都提供了API，直接调用就可以快速实现下面的算法

冒泡排序（bubble sort）:相邻的两个数逐个比较，如果前一个数比后一个数小，那么就交换，当第一轮比较完毕之后最小的值一定产生在末尾。层层比较,需要几轮决定与数组的length.轮数==array.length-1

public static void bubbleSort(int[] array) {
   //比较的轮数
   for(int i=0;i<array.length-1;i++) {
       //每一轮所比较的次数,因为每一轮比较时会产生一个最小值，所以每一轮比较就会少一次
       for(int j=0;j<array.length-1-i;j++) {
           //如果后一个数比前一个数大，那么就做交换
           if(array[j+1]>array[j]) {
               //通过临是变量来存储后一个数
               int temp = array[j+1];
               //把后一个数换成前一个数
               array[j+1]= array[j];
               //再把前一个数换成后一个数
               array[j] = temp;
           }
       }
   }
}

//打印

public static void printArr(int[] array) {
   for(int i=0;i<array.length;i++) {
       //"\t"相当于tab
       System.out.print(array[i]+"\t");
   }
}\

//Todo ios 自带快速排序

    NSArray * array = [NSArray arrayWithObjects:@(1),@(100),@(50),@(4),@(45), nil];
    NSArray * sortArray = [array sortedArrayUsingComparator:^NSComparisonResult(id _Nonnull obj1, id _Nonnull obj2) {
        int val1 = [obj1 intValue];
        int val2 = [obj2 intValue];
        if (val1>val2) {
            return NSOrderedDescending;
        }else{
            return NSOrderedAscending;
        }
    }];

查找，对有序的数组进行二分法查找.while 循环

minindex = 0;maxindex = length-1;midindex = (minindex+maxindex)/2;

如果查找的值大于中间索引的值，我们就在大于中间索引的半个数组中去查找，然后再在半个数组中取中间值，继续比较然后依次二分直到取到值为止。

倒置

public static void reversAray(int[] array) {

   for(int i=0;i<array.length/2;i++) {
       int temp = array[i];
       array[i] = array[array.length-1-i];
       array[array.length-1-i] = temp;
   }
}

二维数组

二维数组就是集合中套集合

数据类型[][] 数组名 = new 数据类型[整数][]

注意:必须明确外围数组名.

数据类型[][] 数组名 = {{},{}}

面向过程

面向对象

面向切面AOP(Aspect Oriented Programming)

//面向对象编程 OOP(Object Oriented Programming)

定义类的语法

class 类名{

属性

方法

}

局部变量必须赋值，否则会报错，无默认值。作用在方法的大括号内，内存存在栈中。生命周期是由所谓的大括号结束就消失

全局变量（类的属性）有默认值，作用在类的大括号内，整个类中。内存存在堆中。生命周期由jvm通过垃圾回收机制自动回收。

匿名对象

匿名对象由于没有栈中的变量引用，所以就不会被回收掉，所以匿名对象是无意义的

面向对象的特性

封装目的是：提高数据的安全性(private,public,)，可以实现对属性的访问权限控制，同时为了程序的可维护性

使用private提升数据的安全性，然后通过public 来访问set/get方法,使用set赋值使用get得到值.

this 关键字

在每一个方法中都包含一个this关键字，代表调用当前调用方法的对象的自身的引用，所以this.age =age。this在set方法中区分同名的变量，加this是成员变量,没有this是局部变量.

压栈，出栈。先进后出，后进先出.main函数里面的其他栈先释放掉，然后main函数作为第一个入栈的函数，最后释放。

构造器

构造器本身就是一个方法，没有返回值,构造器的方法名必须与类名一致,在方法中定义要初始化的参数列表，在构造器中通过this（...）来调用其他的构造器,并且必须是构造器的第一个语句。新建类都有一个默认的构造器，如果在类中没有带有参数的构造器，默认构造器是隐式存在的，如果类中定义了有参数的构造器，那么默认构造器就被覆盖了,如果想要使用默认构造器，只需要把它显式的定义出来就好

public class User {
private String name;
private String password;
private String userName;
public User(String name,String password,String userName) {
   this.userName = userName;
   this.password = password;
   this.name = name;
}
}

和ios init一样

static 关键字

1.static 关键字修饰在属性上。

使用static 修饰的属性我们认为是类属性，不带static修饰的属性我们认为是对象的属性。

2.static 关键字修饰在方法上。

类方法是不能直接访问对象属性的

类方法应用场景：

做工具类

单例模式

设计模式:一共有23中设计模式，设计模式就是有经验的前人通过实践总结下来被大家公认的代码设计思想。

单例模式：这种模式只能产生一个对象。应用场景非常多，

单例模式的创建步骤

1.第一种:懒汉模式

（1）将默认的构造器私有化

(2)在类中定义一个当前类的类型的静态属性，并且创建该当前类的对象。

(3)提供一个静态的类方法返回当前类的静态属性的对象。

public class SignleObject {
public static void main(String[] args) {
   singleton s = singleton.getInstance();
   System.out.println(s);
}
}
class singleton{
   private static singleton s = new singleton();
   private singleton() {}
   public static singleton getInstance() {
       return s;
   }
}

继承

extends

继承的语法

class 子类 extends 父类{}

继承的特点:子类会把所有的属性和方法继承下来(暂时不考虑final)

细节:

1.如果父类中包含了某些类中的共同的属性和行为，我们可以使用继承来设计程序。

2.子类使用extends关键字继承父类的共同属性以外，子类还需要有自己特有的属性或者方法。

3.父类更通用，子类更具体。

4.子类只能获得父类中非private的属性和方法,如果想要继承就得提供公共的set和get的方法.私有的方法是无法继承下来的.

5.java 中只能做单继承

6.java 支持多级继承。

继承的内存结构

super 关键字

1.子类实例化的过程中，父类的构造器先被调用，然后再调用子类的构造器

2.子类通过构造器实例化时要调用父类的构造器，是隐含的调用了super()这个方法。但是如果子类的构造器中调用了父类中的有参数的构造器，那么这个无参数的构造器就不会被调用了。

3.super()的调用必须要放在方法的第一行。

4.super可以表示父类的引用，我们可以使用super和this来区分父类和子类中同名的属性。在子类中访问属性的查找顺序首先在子类中查找指定的属性名字，如果在子类中没有该属性，那么就去父类中去查找该属性，方法也是一样的当子类和父类有同样的方法时通过子类调用的是子类的，但是可以通过super对父类的引用来调用父类的方法.

方法的重写(override)

重写和重载的区别

重写(override)：在父子类的继承中有相同的方法，唯一不同就是方法体，一般是父类的该方法满足不了子类的需求所以才发生重写。

重载(overload):重载是在同一个类中，有着相同的方法名但是参数的数据类型或者参数的个数不同，这两个方法就是重载。

final

1.修饰在方法上

final(最终的) 修饰的方法不能被复写

语法：

权限修饰符 final 返回值类型方法名 (参数列表){方法体}

2.修饰在属性上

语法:

权限修饰符 [static] final 数据类型属性名 =