java知识

• 一、java特点
• • 1.java特点
  • 2. java运行机制
  • 3.书写规范、标识符
  • 4.注释
  • 5.转义字符
  • 6.扫描器
  • 7.引用变量
  • • String，StringBuffer和StringBuilder区别
• 二、if、while、for
• • 1、if 判断
  • 2、while 循环
  • • while与do-while区别
  • 3、for 循环
  • 4、其他
  • • a++与++a区别
    • 局部变量、实例变量的区别
    • for，break，continue区别
    • 函数（方法）
    • 访问修饰符区别
    • 重载、覆盖的区别
    • 递归
• 三、数组
• • 1.数组的定义
  • • 堆、栈区别
  • 2.数组的扩容
  • • 可变长参数
  • 3.数组的插入
  • 4.选择、冒泡（排序）
  • • 选择排序法
    • 冒泡排序法
    • 系统排序法
• 四、面向对象
• • 1.java的发展过程
  • 2.面向对象
  • • 类、方法的结构
    • 重载、覆盖
    • 局部变量、实例变量的区别
    • 构造方法
    • 类加载
    • • 类加载的时机
    • 对象的创建过程（实例变量三次赋值机会）
  • 3、this， supper使用
  • • this调用属性、方法名
    • this()，this(xx)区别
    • supper的使用
    • this与supper的区别
• 三、面向对象三大特性
• • 1.封装
  • 2. 继承
  • • 重载与覆盖
    • 继承特点
    • this、supper区别
  • 3.多态
• 四、
• • 1.
  • 2.

跨平台、简单（比C++而言）、纯面向对象

先编译，后运行

书写规范：一行代码占一行，有缩进

标识符：

• 数字、字母、下划线、$组成。（数字不可开头）

• 区分大小写

• 不可用关键字、保留字(goto、contact等)

• 包名全小写，其他使用驼峰命名法（如类名，方法名）

• 常量全大写，用下划线连接。如A_B

// 行注释
为文档注释

’ ，" ， ， t ，n

扫描器：从键盘输入数据。

Scanner sc= new Scanner(System.in);
int  a=sc.netInt();

char r=sc.next();.charAt(0);

String s= sc.next();
其他与int方式一样。sc.next_()

字符串：字符串不变性。字符串拼接，就是在堆中创建新的字符串。分StringBuffer和StringBuilder
数组：
对象：

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuffer 的方法是线程安全的（不能同步访问），StringBuilder 不安全
StringBuilder 比 StringBuffer 执行速度快，建议使用 StringBuilder 类。在要求线程安全的情况下，则必须使用 StringBuffer 类。

（1）如果要操作少量的数据用 String；
（2）多线程操作字符串缓冲区下操作大量数据 StringBuffer；
（3）单线程操作字符串缓冲区下操作大量数据 StringBuilder；

if(布尔表达式),
布尔表达式：就是true，false。或者为判断语句，如1>2等

while（变量或表达式）
如while(true)，while(1)，while(1>0)

while循环次数不一定
do-while，循环次数一定。先执行，后判断。执行次数多一次

while{
	...
}

do{
	...
}while(判断语句)

格式

for(int i=0;i 
4、其他 
a++与++a区别 
a++：先使用，后a加1
 ++a：a先加1，后使用
 
局部变量、实例变量的区别 
局部变量：在方法内有效，必须先赋值，后使用。命名不可冲突
 实例变量：类中有效。与局部变量命名冲突，局部变量优先。
 
for，break，continue区别 
for：for循环
 break：结束循。
 continue：结束本次循环，继续执行下次循环。
 
for的嵌套 ***
 
函数（方法） 
结构：
 
 函数的声明与实现
 访问修饰符区别
 参数–重载、覆盖（重写）
 
访问修饰符区别 
public，default、protected、private
 

 public是公共的，被public所修饰的成员可以在任何类中都能被访问到。
 protected是受保护的，受到该类所在的包所保护。
 default是对同一package的类友好。
 private是私有的，即只能在当前类中被访问到，它的作用域最小。
 
重载、覆盖的区别 
重载：方法与方法之间。方法名相同，参数列表不同
 覆盖：继承关系。父子类的方法，子类对父类的扩展。方法名、参数列表相同
 
定义区别：
 
重载是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。
覆盖（也叫重写）是指在派生类中重新对基类中的虚函数（注意是虚函数）重新实现。继承关系。即函数名和参数都一样，只是函数的实现体不一样。
 
类的关系区别
 
覆盖是子类和父类之间的关系，是垂直关系；
重载是同一个类中方法之间的关系，是水平关系。
 
产生方法区别
 
覆盖只能由一个方法或只能由一对方法产生关系；
重载是多个方法之间的关系。
 
参数不同
 
覆盖要求参数列表相同。
重载要求参数列表不同
 
递归 
递归：方法自己调用自己。
 
必须有收敛条件。否则会死循环。
必须有返回值
 
三、数组 
数组是引用变量，存在堆中。
 
1.数组的定义 
int a[], a= new int[3]
int a[]=new int[3]
int a[]=new int[]{}
或者int a[]={}
 
堆、栈区别 
数组是引用变量，存在堆中。
 
栈：存局部变量
 堆：存引用变量。
 
引用变量指 字符串、对象，数组、
 
两个数组，如a，a2
 a2=a，
 如果堆中值变化，两个数组都变化。
 
2.数组的扩容 
一般扩容为2倍
 
老数组复制给新数组。新数组的长度比老数组大
System.arraycopy(原数组，原数组下标，新数组，新数组下标，老数组长度)
 old=new ,遍历老数组
用copyof
 
    int[] arr2=new int[arr1.length*2]   //新数组长度

        for(int i=0;i 
可变长参数 
三个点，表示多个参数
 
function(int ...a)
 
可变参，放在参数最后一个，且只有一个
 
3.数组的插入 
先移位，后赋值。
 
for(int i=a.length-1;i>pos;i--){
	a[i]=a[i-1],移位
}
赋值：
b[pos] =value
a=b,指针指过去
 
4.选择、冒泡（排序） 
选择、冒泡为嵌套for循环
 
选择排序法 
i： i=0;i j： j=i;j 
冒泡排序法 
i： i=0;i j： j=0;j 
        for (int i = 0; i < arr.length; i++) {
            //外层循环，遍历次数
            for (int j = 0; j < arr.length - i - 1; j++) {
                //内层循环，升序（如果前一个值比后一个值大，则交换）
                //内层循环一次，获取一个最大值
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
 
系统排序法 
java.util.Arrays.sort(a)，a为数组名称
 
四、面向对象 
1.java的发展过程 
面向过程：自上而下，逐步求精
 面向对象
 APl（高级编程）
 
2.面向对象 
属性：特征，对象有什么。数据库表的字段（列）
 方法：对象可做是什么
 对象的属性，也可以为对象
 
构造方法，局部变量、实例变量。。封装、继承、动态。
 
类、方法的结构 
类的结构
 public class{}
 方法的结构
 public static void 函数名（参数）
 
重载、覆盖 
重载：overloading，方法间（可以是子类继承父类的方法，也可以是不是父类的方法），方法名相同，参数列表不同（参数个数、类型、类型排序不同），有返回值无关
 覆盖：重写，overriding，父子类之间。
 
方法名、参数列表与分类相同。
子类方法的访问修饰符大于或大于分类
子类方法不能比分类抛出更多异常
 
局部变量、实例变量的区别 
局部变量：在方法内有效，必须先赋值，后使用。命名不可冲突
 实例变量：在类中有效。与局部变量命名冲突，局部变量优先。
 
构造方法 
方法名与类名一致
 无返回值
 只能调用一次，不可以手动调用。（一个对象调用一次）
 构造方法无静态
 访问修饰符 class 类名
 如 public class a{}
 
类加载 
当JVM第一次使用一个类时，会根据类的classpath(类路径)找到类的.class文件，获取类的所有信息并保存，并且创建对象。这个过程叫类加载。
 类加载只执行一次
 
类加载的时机 
类加载的时机
 
第一次通过类名 访问静态成员时。（静态成员指 静态属性和静态方法）
第一次创建对象
第一次创建子类对象。（先进行父类的类加载，再执行子类的类加载）
 
类加载发生在所有程序执行之前。
 可以做一些操作。把某些程序放在最前面。
 
所有类变量，在类加载时，分配空间，并初始化。
 
对象的创建过程（实例变量三次赋值机会） 
分配空间：为属性赋默认值
 属性初始化：赋初始值
 调用构造方法：第三次赋值
 
3、this， supper使用 
this， supper只能使用一个，supper必须放在构造方法的第一行
 
this调用属性、方法名 
this调用属性：this.name
 this调用方法：this.a()
 this调用构造方法: this()，this(xx)
 
this()，this(xx)区别 
this()调用无参构造方法，默认提供。
 this(xx)：调用有参构造方法。有this(XX)，this()就无效了，不默认提供了。
 
supper的使用 
super在子类构造方法中使用，调用父类的构造方法
 super()，super(xx)
 
this与supper的区别 
this调用自己的构造方法，supper调用父类的构造方法，都可以调用属性、方法
 supper默认提供
 
三、面向对象三大特性 
封装、继承、多态
 
1.封装 
封装就是private，私有封装，属性私有化，必须通过get、set方法才能访问
 
封装了属性，通过后门的通道来访问
 
使用：
 form表单，在controller直接私有表单，直接可以使用表单，即私有的属性
 
2. 继承 
关键词extends
 如 class Dog extends Animal，狗继承动物，dog是子类，animal是父类
 
重载与覆盖 
重载：出现在方法间，方法可以是不继承的方法，也可以是继承父类的方法。
 
多个方法的方法名相同，参数列表不同
 
覆盖：出现在子类，必须继承关系。
 
子类的方法名、参数列表与父类完全相同。
子类的访问修饰符大于或大于父类
子类不能比父类抛出更多异常。
 
继承特点 
java都是单继承，C++才有单继承。单继承，一个子类只有一个父类。可以使用接口来实现类的扩展，即类似于实现多继承的功能。
 一个类可以有多个间接父类，仅仅只有一个直接父类。
 注意：构造方法不可继承，属性、方法可以继承。
 
this、supper区别 
this()，this(XX)
 supper（），supper（XX）
 supper调用父类构造方法，this调用自己构造方法，均可以调用属性、方法
 supper在子类使用，必须为构造方法的有效第一行。
 supper与this只能存在一个，系统默认提供supper
 覆盖父类的属性叫遮盖
 
覆盖父类的方法叫覆盖，即重写
 
3.多态 
四、 
1. 
2.