java基础

java 起源

90年代印度尼西亚爪洼岛sun公司,现在被oracle收购,mysql和solorais服务器现在也归oracle公司

java三种架构

j2se 标准版，jdk的配置，常用的类包 开发安卓桌面应用（api）
j2ee企业版，web应用 ee为企业分布式应用的开发提供的平台,包含jdbc jndi rmi jms ejb jta等技术
j2me:

配置环境变量

   1. 下载jdk1.8 安装 
   2. 配置 环境path   ----- jdk/bin 路径下
   3. 配置 JAVA_HOME        jdk安装路径
           检测 java -version      javac -version   查看是否一致 
            先javac编译 a.java 成字节码，   然后 java a 解释 （DeskTop）

java和c语言区别

java 基本型 byte,short,int,long ,float,double,*boolean,char(2个字节)*
引用型: 数组array, 类class,接口interface，枚举enum

                  java                               C
1   面向对象,以类为组织单位                     面向过程，函数为单位
2.  数组不可以越键,且定义int a[]不能放数字    可以越键,可以放数字 int a[2]
3. 局部变量必须初始化，没有全局变量         局部变量可以不初始化,存在全局变量
4. 比C语言多 boolean类型,char是2个字节，           char是一个字节
5.  需要真假表达式 判断语句 while(true)          非0 即真 while(1) 
6.gc垃圾回收机制,                                            
7.没有C语言就没有java，java调用了大量C语言写好的dll（dynamic link library库函数,
8.  解释性语言,jvm和操作系统打交道,java解释             编译语言
9.执行是  javac a.java  java a                       gcc a.c 然后 ./a.out
10目前没使用goto                                         goto
11.sizeOf                                          instanceOf 实例
12. 需要添加返回值类型                            默认int 返回值类型## 标题

char和String

char类型

       char ch=' a'; 
                  String x="yan";  char只可以单字符
                  
    System.out.println( ch );          结果字符a
    System.out.println(  (int )ch);      转成数字 97
    System.out.println(ch+2) // 向上转型成  int 类型 99

String 类型 不是基本型，引用型，有final修饰不可变字符，不可以继承

         String str=null;// str在栈，存放地址
       str=new String("YanPeiLun"); //new 在堆申请内存,存放值  
      ***char ch= str.charAt(1);    获取字符
       char c=  str.indexOf("y");  获取索引***
       
        str.trim();去除首尾空
        str.replace( "old老字符", "new 新字符" ); 替换
        str.toUpperCase() 转大写
        str.length();
       str.substring();截取  [);
       
        equals比较值，                    == 比较地址

StringBuffer 和 StringBuilder

   StringBuilder  效率高,不安全
   StringBuffer   效率低,安全    
      常用 reverse(), append(), delete();

面向对象特点

**封装，继承，多态**

1.封装： 把数据封装成包,对属性私有化(增加权限),对外提供方法,保护数据的完整性；

2.继承：子承父(基类，超类),不能直接调用父类的私有方法,（所有的父类都是Object）
        1. 提高代码的利用率；
        2. 可以扩展子类的功能；
        3. 只能单继承；
        
3.多态：方法名相同但是结果不同，运行时多态和编译时多态；
      编译时多态:    重载  overload  参数个数，顺序，类型不同都可以构成重载 (*返回值类型无所谓*)
      运行时多态： 重写override   和父类参数个数保持一致，返回值类型无所谓
                         构造器不可以重写，可以重载

局部变量, 实例变量，类变量(静态变量)

 1.   **局部变量**  ---`存在于函数体内（方法内）,必须初始化`  ,
 2. 存放在栈(地址)
 
 3.   实例变量,跟随对象走，需要new 对象()调用变量  (存放在堆) 
 
 3.类变量，static修饰 , 通过类直接调用变量或者函数,不需要申请内存new,不存在
 this（因为this是对象），引入包的时候直接包名.类.变量(函数)

class test {
int a;
static int b;
test(a,b){
this.a=a;
this.b=b; ----b 2–10 是静态跟着类走 取决于最后的值
} ------------------------ ----t1.a 1 跟着对象
------------------------- ----t2.a 5 跟着对象
main(){
test t1=new test(1,2);
test t2=new test(5,10);
System.out.println(b)-----b作用域是类 跟着类 走

**System.out.println()
   类大写,System
   类直接调用是静态方法,out
   .println()是方法， 因为有()

**抽象类和 接口 **

抽象方法

 1.不能实例化的类( 不能new对象  )，要想实例化通过子类
 
 2只有方法的声明,没有定义     比如 public void start();
 
 3.抽象方法，如果是类,则必须是抽象类，抽象类 可以没有抽象方法(abstract 修饰)
 
 4子类继承,必须.实现父类方法 public void start(){  大括号修饰      };
 
 5.普通变量声明

接口 interface

      1.类多实现接口，class Student implements  Person,People{     }
                 interface Person{
                   void eat();  // 接口只能抽象方法,定义方法 public abstract 修饰
                   int age=10; // 默认static final 常量修饰 int age
              };
      
      2.接口里面只有抽象方法,和常量final

构造函数*

与类同名,没有返回类型，作用申请内存 ，可以 重载,但不可以重写
               public class Test{
                                int a;
                                String b;
                     public Test{   //无参
                          }
                   public Test(a,b){ // 有参 
                   this.a=a;    this指当前对象 
                   this.b=b;
                   }              
                                }

访问修饰符 以及 static

  `public` `protected（同包，子类）` `default（同包）`   `private` 
  
  static 修饰 属类变量或者函数 ,类直接调用

运算符 和 数学类

   + -  * /  % 符号跟左边  
   +                          ++ a 先加1 后运算         
   
                              a++先赋值运算 后 自增 
    
  byte i=3;
   while(i++>2) {// i=3 >2 成立 3++=4 然后4++=5； 5>2循环
	   i++;
   }
   System.out.println(i);//-126
   
  int c=3;
 while(c++<4) { //i=3 i++ 变为4 
	 c++;//4 加1 =5; 5++ >4 跳出 变为 6
 }
  System.out.println(i); 
  System.out.printf("%d",i);



    位运算  不管前后是否正确都要运行前后  &   |       
           ！  ^( 异或 相反为真)
           
           最快的方法实现2*2*2      左移运算 2<<3
     && || 短路, 一真 一假判断 
       Math.random()     随机数[0,1)
            floor() 向上取整 
            ceil()向下取整
            sqrt()开方
            round() 四舍五入

循环控制

 **for*
     遍历 两种方式 
  for(int i=1;i<a.length();i++){  }
  for(String s  str){     }

        while（true）死循环  {  }
        do{   } while();

continue; 不要本次结果,不往下执行,返回循环结构代码
break; 跳出最近的循环

转型错误

浮点数默认double    基本型  0    引用null   布尔 默认false       return 代表结束,或者返回值

        folat f=3.14 ; 错在 3.14是double 型  需要 float f=3.14F;
        
         short a=1 ;    a=a+1;  错在 1 是int 类型 ，结果 应该int 型  不是  short

int 和Integer区别

int 是基本型，Integer是包装类, 事先new好的对象
Integer a=2;
Integer b=2 ; 则 a==b 如果是new Integer(2) 结果不同， 申请内存了，地址改变

常见的异常

       **

1.索引越键 OutIndexOfException
2.栈溢出(自己调用自己) stack
3.空指针 NullPointerExceptiom
4.Io异常 IoException
5.文件找不到 ClassNotFount
6.转型异常 ClassCastException
7.不支持的操作 UnsupportedOperationException（可读问题）
8.端口占用 BindException: Address already in use: JVM_Bind
关闭端口, 1.找到进程号 netstat -ano | find “:3306”
2. taskkill /pid 进程号 -t -f

**