Java语法

1.

使用IDEA工具：

字体大小：File-->Editor --> font

Java : 一门语言
C#sharp(.net 模仿Java)
面向对象
Java:是一种强类型的高级面向对象的编程语言。
强类型：强：要求严格，严谨；
高级：设计思想  编辑逻辑 高级
面向对象：编程思想
语言：沟通交流计算机 软件 系统

（Java EE）上网访问的项目

Java的基本数据类型：
整数：byte short int long 取值范围依次增大
小数：float double 精确度依次增大
字符：char  ''包裹的字符，字符其实对应的是字符unicode的编码 unicode编码：编制了很对字符，各种字符有对应的编码
判断（布尔）boolean

八大基本类型的封装类
                    整数：Byte Short Integer Long 取值范围依次增大
                    小数：Float Double
                    字符：Character
                    判断（布尔）Boolean

创建com包：com所有的意思
流程控制语句：
分支结构，循环结构
1.分支结构：if..else switch
if else
if(满足条件1){
执行此区域的内容
}else if(满足条件2){
执行此区域的内容
}

2.switch分支
switch(条件){
case 条件对应的值1：
     执行此区域；
     break；
case 条件对应的值2：
     执行此区域；
     break；
case 条件对应的值n：
     执行此区域；
     break；
 default：以上值都不满足，执行此区域
}
3.循环结构
while 循环
while(循环条件){
循环区域
}
条件为true，保持循环  false，循环终止

do{
   循环区域
   }while(循环条件)
while 和 do while的区别
while循环先判断条件，在循环；
do...while 先循环一次在判断

4.循环结构 for循环
for(int i=0;i<10;i++){
   system.out.println("循环次数："+i);
}
for（声明条件变量的初始值；利用条件变量作为循环条件：条件变量自增）{
循环区域
}
达到for循环的目的

foreach( 从循环对象中出来的单个元素 : 循环的对象 ){
循环区域
}

----------------------------------------------------------------------------------------------------------------------------------

2.

回顾：
Java八大基本数据类型
1.整数：byte short int long
2.小数：float double
3.字符：char
4.（判断）布尔：boolean

封装类
1.整数:Byte Short Integer Long
2.Float Double
3.Character
4.Boolean
----------------------------------------------
数组（重点）
数组：用来存储多个数据的分组
1.创建数组
a.不声明数组长度，直接存储数组的元素
声明数组的类型 [] 变量名 = new ...
int[] ary1 = new int[]{数据1，数据2};
b.声明数组长度
int ary2 = new int[5];
c.声明数组的元素，静态数组
int[] ary3 = {数据1，数据2，...};

2.排序算法
对数组进行排序，从小到大排序
int[] ary ={4,1,6,4,0,9};
选择排序（效率高）
有选择性的选择某一个元素与其他位置的元素进行比较
选择的位置依次类推，直到所有的位置选择完

冒泡排序
数组中相邻的两个位置进行比较，比较完后依次类推，
比较的轮数  元素个数-1次。
双层循环
内循环A.第一个循环 相邻的两个位置进行比较 范围 0-最大下标-1
外循环B.总共比较的轮数 范围：数组长度减一

---------------------------------------------------------

for (int i = 0; i <ary.length ; i++) {
    for (int j = i+1; j <ary.length ; j++) {
        if(ary[i]<ary[j]){
            int num=ary[i];
            ary[i]=ary[j];
            ary[j]=num;
        }
    }
}
System.out.println(Arrays.toString(ary));

for (int i = 0; i <ary.length-1 ; i++) {
    for (int j = 0; j <ary.length-1-i ; j++) {
        if(ary[j]<ary[j+1]){
            int num=ary[j];
            ary[j]=ary[j+1];
            ary[j+1]=num;
        }
    }
}
System.out.println(Arrays.toString(ary));

-------------------------------------------------------
面向对象   编程思想
类：具有共同特性的抽象事物的概念；
对象：是某一类具体存在的实物  实物是唯一的。类的实例化

先设计类在创建对象
创建对象：调用构造器

构造器：给对象赋值
A.构造器：方法名与类名相同
B.没有返回值类型
C.创建对象:调用构造器
默认构造器：系统会自动生成
创建有参构造器

3.方法的重载
A.方法名相同
B.参数不同：参数个数不同，参数类形不同，参数顺序不同(参数类型不能一致)
C.重载只跟参数有关，与方法的其他都无关
重载的意义：让类似的功能统一方法名

4.类的继承
子类可以继承父类一切非私有的属性和方法
好处：代码的复用性更强，代码利用率更高，提升代码编写效率
缺点：耦合度更高，维度更宽，复杂度更高

class 子类 extend 父类

----------------------------------------------------------------------------------------------------------------------------------

3.

回顾：
数组创建方式：
数组类型：
int[] ary = new int[]{元素1....}
int[] ary = new int[5];
int[] ary={1.2.3};

数组排序：

面向对象
方法结构：修饰符，返回类型，方法名（参数）{
方法体
}
方法重载
方法名相同，参数有关：类型，个数，顺序
与方法任何的结构都无关，比如修饰符，返回类型

类的继承
------------------------------------------
super:超 上一级，父类（子类的上一级）
通过super可以调用父类非私有的属性和方法

方法的重写：把继承父类的方法在修改或者增加方法体

修饰符：访问控制修饰符，非访问控制修饰符
1.访问控制修饰符
public（公共的）
protected（受保护的）
默认（系统自动生成）
private(私有)
作用：设置类，属性，方法的访问权限，控制代码的权限
public :访问权限：公共公开，没有限制
默认（系统自动生成）：访问权限：同一个包下可访问，不同包即不可访问
protected（受保护的）：父类的是可以访问，不在同一个包中，子类可以访问  普通类是不可访问
（访问权限：是否有关系类，是否同包中。不同包中的无关类无法访问）
访问情况：
同包中：本类，子类，无关系类
不同包中：子类，无关系类
private(私有)：本类

注意：public修饰的类，类名与Java文件名相同
Java文件中，只能有一个public修饰的类
main方法只能在public修饰的类创建

2.非访问控制修饰符
非访问控制修饰符：static final abstact
修饰 类，属性，方法的功能
abstact:抽象，修饰抽象方法和抽象类
final:最终的，不可变的；修饰类，方法，属性；
修饰的类，不能被继承，比如 final String class
修饰的方法，不能被重写
修饰的属性，不能被重新赋值。比如：固定密码不可变

static :静态；修饰的属性和方法，代码块，属于类，通过类直接调用
在加载类的时候，只加载一次 ，同时加载静态修饰的属性,方法和代码块

封装
利用访问控制修饰符private  控制类中的属性，设置公开的访问set/get方法供外界调用,set设置属性，get获取属性
符合javaBean的编程规范；
JavaBean
1.类中必须有默认的构造器
2.把属性设置private修饰属性，必须提供公共的set/get方法；
3.set/get的方法名与属性一致

多态
面向对象
动物类（父类）
子类:狗，猫，猴子..
Dog wangcai = new Dog();
多态
父类  变量 = 字类的对象；
animal wangcai = new Dog();

多态的使用
父类 变量 引用的是 子类的对象
父类 变量 = new 子类（）；

类型转化：
向上转型：对象从子类类型转化成父类类型
父类 《--- 子类  :小类型转大类型，自动转化
        //向上转型：向上一级（父类）转型
        Animal a = new Dog();

 向下转型：对象从父类类型转化成子类类型
 //向下转型，从父类转化成子类
         //animal--》dog 大类型--》小类型   强制类型转换
         Dog d = (Dog)a;
         d.work();

  instanceof:判断对象是否是该类的多态类型或子类类型
  语法：
  对象 instanceof 多态类型；
  dog instanceof Animal

  抽象方法
  作用：统一方法的标准，准则
  public abstract void method();

  抽象类
  1.可含有抽象方法；
  2.其他的与普通类一致
  3.抽象类不能实例化，不能创建对象;实现抽象类中的抽象
  4. 可通过重写抽象类，实现抽象类的抽象方法后可创建对象
  比如：
       AbstractClass  a = new AbstractClass() {
              };

----------------------------------------------------------------------------------------------------------------------------------

4.

回顾：
利用JavaBean的规范，把类的属性设置私有的，同时创建set/get公共的访问方法。
JavaBean
1.类中创建构造器
2.把类中的属性设置私有的
3.同时提供公共的set/get方法。
方法名：set+属性名，get+属性名

继承

多态
父类 变量 = new 子类对象
扩展性更强；

抽象类：可含有抽象方法  抽象方法：制定的规范，标准

访问控制修饰符：
-------------------------------
interface
接口
抽象类（包含了普通类，可含有抽象方法）
接口（纯抽象类，只有抽象方法）
作用：提供概念，制定规则，制定类，方法的规则/标准
扩展性更强，面向接口编制思想；

接口与抽象类的区别：
1.声明方式：interface
2.声明属性：接口中的属性默认是公共静态常量
3.声明方式：接口中的方法默认是公共抽象方法

面向接口编程思想：
1.利用接口制定父类的标准，方法的标准。
2.实现的子类根据自己的情况实现不同的功能

3.利用接口调用不同的实现子类，实现不同的功能
异常：程序在执行过程中风险，语法是正常的，逻辑上可能有风险
错误：编译出错，语法有问题

异常处理机制
分两种：
1.抛出异常，抛给使用者来处理，或者抛给上一级处理；
代码：throws Exception
2.捕获异常:在文本中，捕获异常，处理异常，提示异常信息
代码：
    try{
    //被捕获异常的代码
    }catch(Execption e){
    //捕获的异常信息
    }finally{
    //一定会执行，无论异常会不会产生都会执行的代码区
    }
2.认识异常
java中所有的异常类的父类是Exception
主要有两大类异常：runtime exception 运行时异常   和  checked excepion 检查性异常
runtime exception 运行时异常，可抛出虚拟机接管异常，可捕获；比如：空指针，数组下标越界，格式转化...
checked exception 检查性异常，必须捕获处理异常 比如：JDBC,I/O

3.设计异常。
a.继承最大的异常父类：Exception；
b.通过调用Exception的构造器；
c.通过父类构造器，添加自定义的提示信息和新异常

4.使用异常
在方法执行过程中，如果符合异常的条件，就产生异常。

--------------------------------------------------------------------------------------------------------------------------------

5.

回顾：
接口：实现子类的多态，面向接口的编程
1.创建接口
2.子类实现接口中的方法
3.通过不同的子类实现不同的接口
多态的表现

异常：
处理机制
1.抛出异常：throws Exception
2.捕获异常：
try{
//捕获异常的代码区
}catch(){
//捕获异常的提示信息区
}finally{
//最终都要执行的代码区
}

认识异常
所有的异常都继承于Exception（异常的父类）
两大异常：runtime 运行时异常 和 checked 检查性异常；
runtime 运行时异常:处理方式1：抛出 2.捕获
checked 检查性异常：处理1.必须捕获

设计异常
1.继承Exception；
2.调用Exception构造器
3.通过异常的构造器添加异常要提示的信息和其他异常。

使用异常
1.业务需要异常时，抛出异常  throws new Exception();
2.方法参数类别后面 throws Exception;
-------------------------------------------------------
数组：一组数据，用来存储多个元素。固定长度，长度是不可变的。
可操作的方法很少，要通过其他的类来操作元素
只适用临时存储，存储动态的数据不合适

集合：用来存储多个元素
1.长度可变，随者存储的元素动态变化长度
2.本身自带的方法很多，操作方法很方便。
3.扩展性更强，设置泛型；

集合最大的的父类：Collection接口
两个子接口：List , Set
List接口，特点：有序：存储的元素有顺序，可重复（元素是可重复）
Set接口：特点：无序，不可重复（存储的元素唯一）；

List接口的实现类：ArrayList，LinkedList
ArrayList:存储方式：数组；查询效率更高，更新元素效率更低，多线程不安全
LinkedList:存储方式：链表；查询效率更低，更新元素效率更高：多线程不安全
Vector：存储方式：数组；多线程安全
其他特点与List符接口一致
Set接口的实现类：HashSet,TreeSet
HashSet：存储方式：Hash码，哈希码（物理地址值）；
TreeSet：存储方式：树形结构；

List接口中的常用方法：
add():添加元素
ary.get(i):通过下标获取元素
iterator():生成一个迭代器，把集合中的元素放入迭代器中
hasNext():判断迭代器中是否还有元素可迭代；
next():迭代出元素

Set接口的常用方法：
与List集合一样。
Set集合是无序的没有下标，涉及到下标的方法都没有

泛型：规定类型；
集合中规定泛型，元素类型必须符合泛型的规定
比如：
List<String>此集合中必须存储字符串类型
List<？> 还不确定泛型是什么。

java..util.Map<K,V>接口
键值对映射关系的对象；
键：变量
值：数据
一个键对应一个数据，一一对应的关系
Map可以保留很多对的映射关系

与集合相比的区别
一个集合保存一组数据
一个Map保存很多对数据

Map可保存很多对的映射关系，方便存取；
键key，值value
键具有唯一性：每一个键对应一个值
值是可以重复的

实现子类：HashMap<key,value>
存储方式：哈希码；无序排列