java入门基础笔记（在学习c#后）

一.基础

1. byte 是字节型，表示-128——127的整数，不能超出范围赋值，会损失精度。1个byte为8个bit。1KB=1024Byte 、1MB=1024KB.
2. 注释，注释是给人看的，不是机器看的，java中有3种注释，1.单行注释“//”开头多行注释“/*”开头，“*/”结尾。多行注释不能嵌套。3.用于产生帮助文档的多行注释/**  */
3. 强制类型转化有两种方式，一种是类型 变量名=（类型）值；另一种是运用java语言的支持，float a=1.2f;此f大小写均可以。
4. %取余的操作，结果符号与被除数保持一致。
5. 运算符的短路问题：&&的左边如果是假，右边不会执行。||左边为真右面就不会执行。
6. Switch（变量），此处的变量的类型只能是4种，byte，short，int，char。
7. Switch 中break语句正确使用能保证程序的逻辑性。
8. If语句中的布尔表达式不能为数字，与c语言中的不同。
9. Do while 与while 的区别在于，第一个布尔表达式的值为false时，do while 循环体执行一次，而while 不执行。

• 面向对象程序设计

1. 方法的定义不能嵌套。
2. 方法只能定义在类中。
3. 命名约定：类：首字母大写，多单词首字母大写。方法：首字母小写，多单词首字母大写。属性：首字母小写，多单词首字母大写。
4. 属性定义的类中，叫成员变量（初始值，byte int short long是0，float double是0.0  char是‘\u0000’  boolean 的初始值是false），定义在方法中的变量叫局部变量。
5. 构造方法也可以重载，只需看参数，用this（）调用即可，this（）语句必须为构造方法中的第一个语句。
6. 继承（Inheritence）:父子关系，单继承，一个类只能从另一个类继承，被继承的类叫base class，使用extends关键字  super表示对父类对象的引用。super与this一样，必须作为第一条语句。
7. final修饰，变量，类，方法，变量变为常量，不能被重新赋值，类不能继承，方法不能重写，但是可以重载。
8. 抽象类不能被实例化。Abstract
9. 抽象方法有声明，没有实现，没有花括号，后面的分号不能少。紧随抽象类产生的。

例：

1. 接口的地位等同于class，接口中的所有的方法都是抽象的方法。Abstract就可以省略不写。
2. 类可以实现接口，用关键字implements表示，代表了某个类实现了某个接口。
3. 一个类只有一个父类，可以实现多个接口。并且可以同时。
4. 多态， 就是父类型的引用可以指向子类型的对象。
5. Static关键字，用于属性和方法上面还可以修饰类，属性，static修饰属性时，所有成员公用这个静态变量，一个更改，就更改了。直接用类名.成员变量= 10，（java推荐），方法，类名点方法。
6. 24讲20分钟
7. final 类型成员变量，一般来说有两种赋值方式a）在声明的时候为成员变量赋初值。B）在声明时不赋初值，在所有的构造方法中赋初值。
8. Final 修饰引用类型的变量时，不能再次修饰别的变量，但是指向对象的内容是可以变化的。
9. 静态代码块要优先于构造方法的执行，当class文件加载到java虚拟机上的时候静态代码块就已经执行了（只加载一次，从继承得最顶层的静态代码块开始）。构造方法是在生成对象的时候才执行（new一次就执行一次）。
10. 不能在静态的方法里面访问非静态的成员变量。静态方法只能访问静态的变量，非静态方法都可以访问。
11. This是非静态变量。

 

 

Lesson3

1. 接口中的成员变量都是public static final的。
2. 接口中的声明方法都是抽象方法。方法都是public的。
3. 接口中一般只有方法。
4. Abstract 和final，一个类不能同时是这俩，abstract需要被继承，final要求不能被继承。
5. 设计模式。不是技术，是解决问题的方式。Design pattern（设计模式）。单例模式（Singleton），一个类只能生成一个唯一的对象。

单例模式代码：public class SingletonTest

{

         public static void main(String[] args)

         {

                   Singleton singleton = Singleton.getInstance();

                   Singleton singleton2 = Singleton.getInstance();

 

                   System.out.println(singleton==singleton2);

         }

}

 

class Singleton

{

         private static  Singleton singleton;

         private Singleton(){

         }

 

         public static Singleton getInstance()

         {

                   if(singleton == null )

                   {

                   singleton = new Singleton();

                   }

         return singleton;

         }

}

1. 包，用于将完成不同功能的类分门别类，放在不同的目录下，命名规则a）包名小写，如果没有定义包，java认为所定义的类位于默认的包里面。
2. 编译带package声明的类，直接手动建文件夹2.使用编译参数-d . 文件名，包之间有父子关系。
3. 导入（import），将分离的包导入回来。
4. Import 语法 import com.shengsiyuan.test.PackageTest（该位置可以是*，表示所有的了类，但是不能导入他的子包下面的内容。不同位置必须分开导入）；
5. Package import class的顺序

1. 定义包package
2. Import导入
3. 接下来是class和interface的定义。

1. 如果两个类在同一个包下面不用导入直接使用就可以了。
2. 访问修饰符，public
3.   protected 被protected修饰的属性和方法可以在类内部、相同包、以及该子类访问（不再相同包也可以）
4.  private 子类不会继承private修饰的内容。
5.  不加任何的访问修饰符，类内部可以使用，相同包下面可以使用。

	类内部	相同包	子类	类外部
Public	V	V	V	V
Protected	V	V	V	X
Private	V	X	X	X
默认	V	V	X	X

1. instaceof ： 判断某个对象是否是某个对象的实例，语法形式：引用名 instaceof 类名（接口名），返回一个boolean的值。MAN是people的实例，子类是父类的实例。
2. 相等性比较，

对于原生类型，左右两边的值是否相等。

对于引用类型，左右的地址是否一样。

1. java.lang.Object类，java.lang包在使用的时候无需显示导入，编译的时候有编译器自动帮助我们导入。
2. API （Application Programming Interface）,应用编程接口。
3. 当打印 引用时，实际上会打印引用所指对象的toString（）方法的返回值。每一个类都有toString()方法。
4. equals()方法，该方法定义在Object类中，因此在java中每个类都有这个方法，调用equals方法的对象与传进来的对象是不是指向同一个对象。等价于==
5. 对于String类来说，equals方法是判断当前字符串与传进来的字符串的内容是否一致。
6. 对于String对象的相等性判断来说，使用equals方法，不使用==，==判断的是是不是同一个对象（如果没有重写的话）。
7. 字符串是常量，其对象被创建后就无法被改变，+拼接时是生成一个新的字符串对象而不是在原有对象追加内容。
8. String Pool (字符串池)，用字面值方式赋值，里面没有才会创建对象，有就不创建对象而是直接指向原有对象。
9. String s =”aaa”;（采取字面赋值的方式）

1. 查找String Pool 中是否有“aaa”这个对象，不存在就创建一个，存的就把aaa对象的地址返回来。赋给s。

1. String s = new String（“aaa”）；（new就会创建对象）

1. 首先在String poll 中查找有没有“aaa”对象，有就不创建，直接在堆中创建对象，地址返回。如果没有，pool中创建，堆中也创建一个对象，将堆中地址返回。

数组

1. 包装类（Wrapper Class）。针对原生数据类型的包装，所有的包装类都位于java.lang包下，java的8个包装类是Byte，Short ,Integer,Float,Double,Character,Boolean,他们的使用方式是一样的，可以实现原生数据与包装数据的双向转换。

 

1. 数组（array）：相同类型的数据的集合叫数组。
2. 如何定义数组：type [ ] 变量名= new type [数组中的数]；

例： int[] a = new int[10]          int a[] = new int [10]

1. 数组中的元素索引是从0 开始的，对于数组来说，最大的索引==数组长度减1.
2. 每一个数组都有一个length属性，length是public、final、int的，当数组长度一旦确定，就不能更改。
3. 3中的a表示引用，a数组的首地址。
4. 二维数组。
5. A Instanceof type ；A 是不是后面的类型，返回true或者false
6. 可以定义不规整数组：int [][] a = new int[3][]

A[0]= new int[2];

A[1]= new int [3];

A[2] =new int [1];

或者直接放内容：

int [][]a = new int [][]{{1,2,3},{4},{5,6,7,8}}

1. 不能先定义列，可以先定义行。
2. 不使用中间变量实现两个数的互换，

a =  a +b;

 B = a -b;

A= a-b;

12.I[] i = new I[2];

                   i[0]= new C();

                   i[1]= new C();

上下两个方式实现的效果一样的。

                   I[] b = new I []{new C(),new C()};

1. 冒泡排序（掌握叫唤排序和快速排序的原理和实现方式），快速排序是两端互换。

 

 

/**

 * 快速排序演示

 * @author Lvan

 */

public class QuickSort {

    public static void main(String[] args) {

        int[] arr = {5, 1, 7, 3, 1, 6, 9, 4};

 

        quickSort(arr, 0, arr.length - 1);

 

        for (int i : arr) {

            System.out.print(i + "\t");

        }

    }

 

    /**

     * @param arr        待排序列

     * @param leftIndex  待排序列起始位置

     * @param rightIndex 待排序列结束位置

     */

    private static void quickSort(int[] arr, int leftIndex, int rightIndex) {

        if (leftIndex >= rightIndex) {

            return;

        }

 

        int left = leftIndex;

        int right = rightIndex;

        //待排序的第一个元素作为基准值

        int key = arr[left];

 

        //从左右两边交替扫描，直到left = right

        while (left < right) {

            while (right > left && arr[right] >= key) {

                //从右往左扫描，找到第一个比基准值小的元素

                right--;

            }

 

            //找到这种元素将arr[right]放入arr[left]中

            arr[left] = arr[right];

 

            while (left < right && arr[left] <= key) {

                //从左往右扫描，找到第一个比基准值大的元素

                left++;

1.             }

            //找到这种元素将arr[left]放入arr[right]中

            arr[right] = arr[left];

        }

        //基准值归位

        arr[left] = key;

        //对基准值左边的元素进行递归排序

        quickSort(arr, leftIndex, left - 1);

        //对基准值右边的元素进行递归排序。

        quickSort(arr, right + 1, rightIndex);

    }

1. }
2. 对于java中的常量命名规则，所有单词都是大写。多个单词使用下划线。

二分法查找：带查找数组要有序。

1. Public static final intAGE_OF_PERSON
2. Idea 的快捷键

1. psvm ------快速生成main函数
2. Sout ------打印输出
3. CTRL+ y删除一行
4. ctrl+alt+f10运行
5. 左边窗口中的列表怎么展开怎么关闭？用左右箭头
6. 任何窗口的关闭都是esc
7. 新增新建都是alt+insert
8. 窗口变小变大ctrl+shift+f2
9. 切换java程序alt+左右箭头。
10. 切换窗口alt+窗口前面的数字
11. 提示方法的参数ctrl+p
12. Idea中怎么定位方法，光标停在单词下面点进去。

1. 如果增加数元素的个数超过10个，那么ArrayList底层会新生成一个数组，长度变为原数组的1.5倍+1.然后将原数组copy到新的数组中，并且后续增加的内容会放到新的数组中，当新数组无法容纳增加的数组时，重复该过程。
2. 对于Array List 元素的删除和插入需要对操作位置后面的元素进行操作，代价比较高。
3. ArrayList 只能放对象的引用，不能放原生数据类型，需要对其进行包装才能进行。
4. 集合中放置的都是object 类型。
5. Arraylist 底层是数组实现，linkedlist是使用双向链表实现的。

1. 实现插入删除linkedlist更好
2. 执行搜索array list更好。

1. Object 类的equals方法

1. 自反性，
2. 交换性
3. 传递性，

 

1. 重写equals方法也必须重写hashCode方法，反过来也一样。
2. Map 的keyset方法会返回key的集合，因为map的建是不能重复的，map的值是可以重复的，所以values()返回collection。
3. 策略模式。
4. 向HashMap 中put 一对键值时，他会根据key的hashCode值计算出一个位置，这个位置就是此对象准备往数组中存放的位置。
5. 如果该位置么有对象存在，就将此对象直接放进数组中，如果该位置已经有了对象，顺着此对象的链开始寻找，（Entry类有一个Entry类型的next成员变量，指向了该对象的下一个对象），如果此链上有对象的话，再用equals方法进行比较，如果对此链上的某个对象的equals方法比较为false，则将该对象放到数组中，然后将数组中该位置以前存的那个对象链接到此对象的后面。
6. Vector 矢量，

System.getProperties();得到系统环境变量。

1. 所谓泛型，就是变量类型的参数化。
2. 泛型可以限制参数的类型是什么，用extends关键字来实现，后面接的是接口的话，仍然使用extends关键字。如果没有指定泛型的类别，那么默用T extends Object.
3. 当使用增强的for循环时，如果需要访问集合的或数组的下标，不用这个增强的for循环。
4. Integer 类会有一个缓存，他会缓存介于-128~127之间的整数。
5. 可变参数就是一个数组，对于一个声明了可变参数的方法来说，我们可以传离散的值也可以传数组对象。如果方法中定义的是数组，就只能传递数组而不能传递离散的值。
6. 可变参数必须要作为方法参数的最后一个参数，即一个方法不可能具有两个或两个以上的可变参数。
7. 615
8. Java中对日期的处理。System.currentTimeMillis自1970年1月1日0时0分0秒000毫秒到现在的毫秒数，用long类型来存储。
9. 数字格式化，
10. P626
11. 枚举：枚举是一种引用数据类型，枚举的定义语法enum枚举类型名{枚举值1，枚举值2}，若结果只有两种，类型，无需枚举，bool就能完全解决。结果超过两种，可以列举出来的就可以用枚举。
12. Switch支持枚举string，int
13. Java中异常以类的形式存在。
14. Java中异常处理的方式有两种，1是在方法声明的位置上使用throws关键字。

2是使用try{}catch{}语句。Catch写多个的时候要从上到下，从小到大的顺序执行。Jdk8新特性。Catch后面可以使用或的“|”的形式进行多个异常的书写。

44.try。。catch使用方法，如果希望调用者来处理就上报，否则就自己处理。

45.异常追踪信息要从上往下看，除了sun公司写的外的第一个就是自己的错误。

46.finally必须和try catch一起用，无论啥情况finally里面的语句都会执行。

47.try里面有return 并且有finally，先执行finally里面的内容，在执行return，catch可以没有。

48.try中有System.exit（）；finally中的代码不执行。只有这个可以治他。

49.java中有一条规则，方法体中代码必须遵循自上而下的原则执行。

Return语句一旦执行，整个方法必须结束。

50.方法覆盖中。重写之后的方法不能比重写之前的方法抛出更多（更宽泛）的异常。可以更少。

51.所有的流都实现了closeable接口，都是可关闭的，避免占用内存资源。

所有的输出流都实现了flushable接口，都是可刷新的，最终输出之后将管道中剩余未输出的数据强行输出完。

52.idea的默认文件路径是工程project的根目录。

53.fileinputstream的read（byte【】 b）方法返回的是读取到的字节的数量，不是字节本身。

54.serializable 序列化接口，transient 游离，不被序列化进去。

P744 615

55.线程的方法

56.线程的同步机制，synchronized可以在方法体，不常用，扩大范围，有局限行，优点代码少，

57.局部变量不需要用同步机制。STring builder用局部变量。

58.线程总结，尽量使用局部变量，多创建对象减少实例变量的数量，万不得已再使用synchronize。

234

 

                                  Spring       

• 控制反转ioc，是一个理论，一个思想，概念：把对象的创建赋值管理工作都交给代码之外的容器实现，也就是对象的创建是有其他的外部资源控制实现，
• 控制：创建对象，对象的属性赋值，对象之间的关系管理
• 反转：把原来的开发人员管理、创建对象的权限交给代码之外的容器实现，有容器代替开发人员管理对象并给属性赋值。
• 正转：由开发人员在代码中使用new方法创建对象，开发人员主动管理对象。
• 容器是一个服务器软件，一个框架。
• 为什么使用IOC，目的就是减少对代码的改动，实现不同功能，实现解耦合，代码改动量很少。
• Java中创建对象的方式：1.构造方法2.反射3.序列化4.克隆5.ioc6.动态代理
• Ioc的体现，servlet 1：创建类继承HttpServlet  2.在web.xml注册Servlet使用<servlet-name>myservlet</servlet-name> 3.没有创建Servlet对象，tomcat容器实现。
• Ioc的技术实现，DI是ioc的技术实现，依赖注入，我们只需要在程序中提供要使用的对象名称，有名称就可以找到一个容器中的对象，
• Spring是使用di实现ioc的功能，底层用反射实现的。
• Spring 是一个容器，管理对象，给属性赋值，底层是反射创建对象。
• Beans是根标签，spring吧java对象称为bean。
• 加入maven依赖spring-context ，在加入spring-context的同时，间接加入了spring-aop的依赖，加注解必须使用spring-aop依赖。
• 学习的注解有

@Component

创建对象的，等同于<bean>的功能，

属性：value 就是对象的名称，也就是bean的id的值，

Value的值是唯一的，创建的对象在整个spring的容器中就只有一个。

@Respotory：创建dao

@Service：创建service处理事务的功能

@Controller：创建控制器，在控制器层面上，与接收请求，显示处理结果的

@Value

@Autowired

@Resource

解决maven创建过慢的问题

archetypeCatalog

internal