java笔记002

java 虚拟机--对.java文件编译成.class文件，再JVM中运行

栈区(stacksegment)存放函数的参数值，局部变量的值等，在超过这个变量的作用域时就会被系统自动释放掉存在于JVM内存中的资源
优点：存取速度比堆快
缺点：存在栈中的数据大小(类型来决定大小) 与生存期必须是确定的，无灵活性

堆区(heapsegment)存放由new创建的对象和数组，JVM不定时查看这个对象，如果没有引用指向这个对象就回收
优点：可以动态分配JVM内存
缺点：要在运行时分配JVM内存 速度慢

// 基础类型是存放在栈内存中的             （java中除基础类型其他都是引用类型）
 引用类型引用的变量在栈内存，new出来的实实在在的东西是放在堆内存中的，访问这个是指在在的东西是通过访问这个引用类型，然后通过引用类型指向的它才能访问  int in=new Scanner(System.in);  xx=in.nextInt(); 
                           
java有哪些数组类型？
char    char[]
int int[]
double double[]
String String[]
Scanner Scanner[]
Random Random[]

数组使用方式 //需定义数组；分配空间；赋初值
第一种：int arr[];  //两种写法int[] arr和int arr[]
 arr=new int[5];
 arr[0]=123; //未赋初值则int默认0；String默认null
第二种:int[]=new int[5];
 arr[0]=123;
第三种：int[] arr={23,45,48};
 或int[] arr=new int[]{23,45,48};

自定义数组的长度
 int num=in.nextInt(); //键盘录入赋值
 int[] arr=new int[num];
数组length属性 arr.length
数组排序 Arrays.Sort(数组名); 再for(i++或i--来顺序输出)

数组的使用：
1.数组的复制
 int[] arrA={1,2,3,4,5,6,7,8};
 int[] arrB=new int[arrA.length];
 for(i=0;i<=arrA.length;i++){
 arrB[i]=arrA[i];
 }
2.查找算法（搜索）
 String name=in.next();
 String[] arr={"张三","李四","王二","麻子","壁虎"}；
 boolean flag=false;
 for(int i=0;i<arr.length;i++){
    if(name.equals(arr[i])){
  flag=true;
  break;
    }
 }
 if(flag=true){
  System.out.println("找到了");
 }else{
  System.out.println("没有找到");
 }
3.插入算法
 int num=in.nextInt();
 arr[arr.length-1]=num;
 for(int i=arr.length-1;i>0;i--){
    if(arr[i]<arr[i-1]){
     int t=arr[i];
     arr[i]=arr[i-1];
     arr[i-1]=t; 
    }else {
      break;
    }
 }
4.冒泡算法  相邻比较得到大数
 int[] arr={23,12,87,65,14,13};
 for(i=0;i<arr.length-1;i++){
     for(j=0;j<arr.length-1;j++){
         if(arr[j]>arr[j+1]){  
    int t=arr[j];
    arr[j]=arr[j+1];
    arr[j+1]=t;
  }
     }
 }
 
或
 for(i=1;i<N;i++){
     for(j=N-1;j>=i;j--){
       if(num[j]>num[j-1]){
  num[j]与num[j-1]交换； //这种更形象些
  }
     }
 }

 

5.选择算法 （比冒泡排序效率高）相邻比较得到大数，大数不再进行比较
 int[] arr={34,54,6,87,98,54,3432,1};
 for(i=0;i<arr.length-1;i++){
     for(int j=i+1;j<arr.length;j++){
  if(arr[i]>arr[j]){
   int t=arr[i];
   arr[i]=arr[j];
   arr[j]=t;
   }
     }
 }
 for(i=0;i<arr.length;i++){
 System.out.println(arr[i]);
 }

多维数组 int arr[][]={{1,2},{3},{7,8,56}}

 int[][] arr={{23,43},{65,76,87},{54,35,86},{55,65,74,888}}
 System.out.println(arr[3][3]);
java中多维数组的声明和初始化，按照从高维到低维的顺序进行。如下：
 int a[][]=new int[3][];
 a[0]=new int[2];
 a[1]=new int[4];
 a[2]=new int[3];
 

 面向对象
Eclipse和myEclipse（jdk集成安装jre，无需自己配）
Eclipse中快捷键：
alt+/ 代码自动提示（完成）自动包导入 eg：main自动完成

包--解决类的同名问题（对应一个文件夹）更好的保护类、数据和方法

预定义Class：
写java程序的时候默认载入包java.lang，而java.lang里面已经存在了很多Class

自定义Class：
class UserInfo{
     ……
}

【Java变量】
四种：类变量（又称为静态变量）、实例变量、局部变量、块变量

类变量——只能在一个class域里面进行定义，只能在类里面使用，关键字为static
class UserInfo{
    static int A;

    public static void main(String args[]){
        System.out.println(UserInfo.A);
    }
}

实例变量——也是在class域里面进行定义，只能在Object域里面使用，不使用关键字static
class UserInfo{
    int a;

    public static void main(String args[]){
        UserInfo user = new UserInfo();
        System.out.println(user.a);
    }
}

局部变量——只能在函数域里面定义和使用，每个函数中定义的局部变量只能在函数本身中使用
class UserInfo{
    public static void main(String args[]){
    }
    public static void f(int i){ 
      int a = 0;
    }
}
块变量——只能在块域中进行定义，同样只能在块中使用
class UserInfo{
    public static void main(String args[]){
        {  int a = 0;
        }
    }
}
类变量和实例变量在没有进行显示初始化的时候，系统会自动赋予默认值
块变量和局部变量必须进行显示赋值操作，否则无法通过编译器的编译。

Java中有一种初始化的方式称为静态初始化，静态初始化会存在于class域的一个static块语句里面，所有静态初始化的语句会在类加载的时候第一时间执行 
特性是：它只运行一次，仅仅在类第一次被JVM加载的时候会执行

Java变量修饰符和访问域（变量相关）：
　  public域：public域使用public关键字来实现，任何成员都可以访问的，访问前提是已经导入了该类所在的包
　　protected域：protected域使用protected关键字来实现，访问该类的类必须和被访问类在同一个包里面，或者访问类是被访问类的子类
　　private域：private域使用private关键字实现，该关键字定义的东西只有该类本身可以访问，其他类以及子类都不可以访问该成员
    default域：default域不需要用任何关键字来实现，直接在类里面定义实例变量或者类变量的时候不带任何修饰符，访问类和被访问类必须在同一个包里，default又称为包域

编程过程中，.java文件对应的就是一个class的类名称
一个.java文件里面最多拥有一个public修饰的class，而必须和.java源文件同名

【继承有两种方式】类继承（extends）和接口继承（implements），
一般情况下，extends用来描述is-a关系，而implements用来描述has-a关系。

子类会具有比超类更多的数据和功能
Java中所有的类都直接或者间接继承于Object类，可认为Object是所有Java类的超类
一个类只可以继承于另外的一个类
一个类可以实现多个接口
接口本身支持多继承关系，其意思为一个接口本身可以从另外几个接口继承过来，接口继承的时候，只能使用extends关键字，不能使用implements

　　接下来再看一段代码，以下都为合法的写法：
　　interface AA{}
　　interface CC{}
　　interface BB extends AA,CC{} //这是一个接口继承于另外一个接口
　　class A{}
　　class B extends A{} //类的单继承
　　class C extends A implements AA,CC{} //类继承于某个父类而且同时实现多个接口操作

　　继承（extends）和实现（implements）的规则如下：
　　extends：子类可以继承父类除private的所有属性和方法，子类调用父类用super关键字，父类里面被标记为final的成员函数同样是不能继承的
　　implements：子类实现了某个接口过后，必须实现接口中所有的抽象方法[接口中的方法默认是抽象的]，所有的接口实现方法都必须写出它的实现过程
　
　
【抽象类、接口、final类】
 抽象类——使用abstract作为类的修饰符，该类里面可以仅仅包含一些方法的定义，可以不需要该方法的实现。

当一个类里面的方法为抽象方法时，该类一定是抽象类，
当一个类是抽象类时，里面的方法不一定是抽象方法或者说这个类里面不一定包含了抽象方法
 
　　先看一段代码来理解整个流程：
abstract class BaseUser{
    //抽象类里面的具体方法
    public void helloImpl(){    System.out.println("Hello"); }
    //抽象类里面抽象方法，直接在函数后边使用“;”而不带任何函数体
    public abstract void helloAbstract();
    public abstract void helloSecondAbstract();

}

 接口——可以理解为一个特殊的抽象类，不使用abstract来定义，直接使用interface关键字定义
接口里面所有的方法都是抽象方法
接口没有构造函数
接口没有内置的this和super变量
接口的成员变量一定是常量
接口的成员函数的修饰符均为public
interface A{
    int A_INT = 0;
    void fun();
}
 final关键字——
final用于变量，表示该变量存在内存里面的值为一个常量，不可更改
final用于一个方法，表示该方法不可以被继承，即使该方法为public 可被子类调用
final用于一个类定义，表示该类不可以有子类
final用于变量，表示该引用不可以指向其他的对象

重载（Overloading）——类中可以创建多个方法，它们具有相同的名字，但是却具有不同的参数列表和不同的定义
重写（Overriding）——