java笔记

0 Java认知

0.1 语言特点

java=c ++ -复杂性和奇异性+安全性和可移植性

• 简洁性：舍弃c++中头文件、指针、结构、联合、隐式类型转换和操作符重载；支持单重继承和接口实现多继承，自动内存分配和回收。
• 面向对象：除数值、布尔和字符三种基本数据类型，其余类型均是对象；支持封装（对象内数据和代码联编形成对象），多态（一个接口有多个内在表现形式）和继承（某一对象直接使用其他对象的属性和方法）
• 动态性：java类是动态装载的，可以动态维护应用程序和支持类库间的一致性，类库中可以自由加入新方法和实例变量而不影响程序执行，通过接口实现多重继承。
• 平台无关性（可移植性）：编译器生成的可执行代码（不针对具体的软硬件，而是字节码）是基于JVM（java virual machine）（运行经过编译的java代码的假想计算机）来实现的。
• 安全性：JVM对字节码加密传输，客户端校验且解释器在客户端临时分配、布置内存管理；对内存的访问是通过对象实例变量实现的；避开了指针操作的安全隐患；提供内存管理机制，自动收集内存垃圾；运行环境供四级安全性保障机制：字节码校验器、类装载器、运行时内存布局和文件访问限制。
• 高性能：字节码易于转换为特定处理器的高性能机器码。
• 多线程：自身多线程利用系统空闲做常规处理，支持多线程语言，提高程序执行效率。
• 分布式：适用于网络，适用于分布式计算，提供类库支持TCP/IP协议处理，支持WWW的C/S和B/S的计算机网络模型。

0.2 分类

• Application:由java解释器控制执行，可以在任何装有JVM的计算机上运行；必须有一个类定义了main()方法；
• Applet:嵌入到Web网页中，由兼容Java的浏览器运行，依赖HTML文件和Web浏览器，没有含main方法的主类。

0.3 三个版本

1、JavaSE(Java Standard Edition)

也称为J2SE，标准版本。用于服务器、桌面、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为 Java Platform，Enterprise Edition（Java EE）提供基础。

2、JavaEE(Java Enterprise Editon)

也称为J2EE，是企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端Java 应用程序。Java EE 是在 Java SE 的基础上构建的，它提供Web服务、组件模型、管理和通信 API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和 Web 2.0 应用程序。

3、JavaME(Java Micro edition)

也称为J2ME，是网络这一块的，Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。

Java ME 包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于 Java ME 规范的应用程序只需编写一次，就可以用于许多设备，而且可以利用每个设备的本机功能。

1. 程序基本结构

1.0 包、引用和接口

1.0.1 包和引用

java语言的源程序是一个或多个.java为扩展名的文件，包含：

• 包声明（package语句）：为类、接口指定所属的类库；
• 引用语句（import语句）：包语句之后，所有类和接口之前，应用类
  
  
  
  
  
  比较变量地址

1.0.2接口

• 定义：接口使处于不同类层次，不相关的类可以具有相同的行为，是方法定义和常数变量的集合。
• 作用：指明多个类需要实现的方法/了解对象的交互界面而不需要了解对象对应的类/可以实现不相关对象的相同行为。
• 格式

interfaceDeclaration{
interfaceBody//其中所有方法都abstract,具体如下：
type constantName=value;//接口的成员变量都是常量，具有public,final和static属性，可以省略这些修饰符
returnType methodName([paralist]);//只有声明，没有实现，具有public和abstract属性

}

• 如果子接口中定义和超接口同名的常量或相同方法，超接口中常量被隐藏，方法被覆盖。/接口实现必须由（非抽象）类非抽象实现/类的声明中用implements来实现接口，不同于extends表示继承，且一个类可以实现多个接口，类实现接口就必须实现接口中所有方法。

//接口实现案例
import java.lang.*;
//引入包
 
public interface Animal {
   public void eat();
   public void travel();
}
public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

• 接口与抽象类比较：
  
  

1.1 类和对象

1.1.1 基本概念

• 对象：类的一个实例，有状态和行为，是计算机语言对事物的描述，通过属性和方法来对应事物具有的静态动态特征（对象是成员变量和方法的集合体）
• 类：描述一类对象的抽象概念。

public class Cat{//类头
//类体
int furColor;//定义成员变量
float weight;
//定义成员方法
public void catchMouse(Mouse m){//方法声明
//方法体，当方法返回类型不是void时，必须有return expression
}
}

• 局部变量：在方法中声明和初始化，方法结束后变量销毁。
  成员变量：类中，方法之外，表示对象属性，带有初值0，在创建对象时
  才实例化，成员变量可以被类中其他语句访问（全局）。其中，用final修饰符的变量就像常量一样使用，只读不改。

类变量：类中方法之外，用static修饰的变量，可以被其他方法调用，静态成员变量，类成员变量既可以用对象名访问，又可以用类名访问。
实例变量：独立于方法之外的变量，不过没有 static 修饰。创建实例才能访问，只能通过对象访问。

1.1.2 内部类 匿名类

• 内部类：在一个类中声明另一个类，内部类可以调用外嵌类的成员变量和方法，不能声明类变量和类方法（静态变量和方法）
• 匿名类：使用父类的构造方法+自己的类体，创建一个子类对象，省去类声明，代码更简洁。
  eg：

//People是类或者接口，用其子类创建对象如下：
new People (){
//匿名类类体
}；

1.2 方法实形参，过载

• 方法调用时的参数传递：方法调用时，其参数的数据传递是值传递，实际参数（调用方法时所带的参数，具有具体值）传递给形式参数（在方法创建时定义，在结构上起占位的作用）。方法调用时实际参数值将数值赋给形式参数，形参的值发生变化不影响实参。
• 方法过载：同一个类中方法名相同，参数不同（数量或者类型），由调用时的实参决定调用的方法是哪个。

为什么不根据返回值对方法加以区分：调用时不能指定类信息，编译器不知道你要调用哪个类。函数的返回值只是作为函数运行之后的一个“状态”他是保持方法的调用者与被调用者进行通信的关键，并不能作为某个方法的“标识”。网上案列主要意思就是不能通过给予不同的返回值类型加以区分。因为在java语言规范层方法在调用时可以不将返回值赋值给一个对应的变量，这样就无法去有效进行方法分配。

1.3 类的构造器

构造方法的名称必须与类同名，一个类可以有多个构造方法。

public class Puppy{
   public Puppy(String name){//与类同名的构造方法
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );//【声明】：对象名称和类型；【实例化 】：用new来创建一个对象；【初始化】：使用new创建对象时调用构造方法初始化对象
   }
}

import 包名.类名;
import 包名.*;

• 类和接口声明：类包含成员变量和方法，表示对象的基本属性和行为，接口表现对象具有的行为规范。若某个类中有main()方法（程序运行的入口），则该声明其为public类（一个程序中只能有一个）且其名字作为文件名。

1.4 超类子类和继承

• 继承：重新使用接口。能创建一个通用可被继承类。超类被子类继承。
• 继承的特性：

• 单一继承性：子类只能有一个超类，而超类可以有多个子类；
• 子类继承超类所有成员，并且可以创建自己的成员。（但是被private修饰的成员变量和方法虽然继承却不能访问）
• 子类不能继承超类构造器，只能在构造器中通过super()调用超类构造器。并且首先调超类构造器再执行自己的构造器
• 多态性：子类的成员可以隐藏和覆盖超类中相同成员（隐藏相同的成员变量，覆盖同名同参同返回类型的成员方法）（方法重载是同一个类中具有相同名而不同参数的方法，区别于方法覆盖）/超类的对象可以对子类的实例引用（若子类重写了超类中的一个方法，使用超类调用时调用的是子类的方法/当超类对象对子类实例引用时，这个对象访问的必须是超类中所具有的，不能访问子类自己创建的成员/只有当对象被强制转换成子类类型时这个对象的所有成员才可能被访问）。
• abstract修饰的类必须被继承，修饰的方法必须被覆盖，abstract类中可以有非abstract方法，但abstract方法必须在abstract类中。构造方法，类方法和私有方法不能被abstract，因为她们本身就不能被重写，定义为抽象则无法实现。

abstract class abstractClassName{
abstract returnType methodName([paralist]);//没有语句实现部分
}

• final修饰的类不能被继承，修饰的方法可以被继承、重载，但不能被重写覆盖。
  

示例：


构造器先行父类再行子类：

• 运行时的多态：
  对于覆盖或继承的方法，java运行时系统根据调用该方法的实例的类型来决定选择哪个方法调用：对于子类的一个实例如果子类覆盖了超类的方法，则运行时调用子类的方法，如果子类继承但没有覆盖超类方法，则调用超类方法。

什么情况下出现运行多态？继承重写，父类引用指向子类对象
运行多态优点？可替换可扩充/消除类型之间的耦合关系/接口统一灵活简化

1.5 3个关键量

• null 表示变量为空，对象或数组还没有相应的实例引用；
• this对类的实例访问，对象对该实例的引用访问；在类中用于指向成员变量，区别于非成员变量（解决变量重名问题）/在构造器中使用this()形式对另一个构造器调用/类创建时，表示对自身实例访问。
• super:用于访问被隐藏的超类变量，被覆盖的超类方法和超类构造方法。

2. Java字符集

使用Unicode(统一码字符集)，16位存储空间，当其高八位为0时即ASCII码
*关键字：true、false、null为小写，不能大写；sizeof不是关键字；goto\const不是关键字，是保留字。

• 标识符：字母、下划线、美元开头，由以上和数字构成；类名接口名用名词，大写分割（class WordTool）,方法名用动词，首字母小写（depositAccount(）),变量名用名词或形容词，首字母小写，常量全大写，下划线分割（PERSON_COUNT）

3 数据类型

• 引用数据类型：数组，class和interface声明变量时声明的变量不是数据本身而是数据的引用，需要用new运算符来为引用类型的变量分配贮存空间。

4 常量变量

常量：‘数值或者字符’
变量：type varname(=初值);
依据作用域可以分为全局（成员变量）和局部（方法、语句块和异常处理的变量）

• 自动类型转换：int a=10;long b=a;

低 ------------------------------------> 高 byte,short,char—> int —> long—> float —> double（byte short char 之间不能相互转，只能间接通过int）

• 强制类型转换：int s=(int)3.14159;
  
  

//九九乘法表实现
package multiplication;
public class multiplication_9 {
    public static void main(String[] args) {

        int i, j;
        for (i = 1; i < 10; i++) {
            for (j = 1; j < i + 1; j++) {
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();

        }

    }
}

*java语言的逻辑运算的优化的含义是什么：如果第一操作数在某种值的情况下，就可以确定结果，就不用再去访问第二操作数，这样就简化了运算，特提高了程序的运行效率。

5 语句之流程控制

流程控制即根据一定条件判断而选择程序执行顺序序列（程序流）

5.1 分支语句：

• if-else

if(b){
block;
}else{
block;
}

• switch

switch(intexpression){
case int1:
statement or block1
break;
case int2:
……
default:
statment od blockd
} 

5.2 循环语句

• while

[initialization]
while(expressionBool){
statements;
}

• do-while

[initialization]
do{
statements;
}while(expressionBool);

• for

for(initialize;condition;iterat){
statements;
}
//遍历功能循环
/* for(类型 变量名：集合){
block;
}*/
int[] numbers={43,32,45,65,46,86};
for(int array:numbers){
System.out.println("Count is :"+item);}

break 跳出最里层的循环，并且继续执行该循环下面的语句。
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。

在 for 循环中，continue 语句使程序立即跳转到更新语句。

在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

//求101到200之间的质数及其个数
package plus;
public class pluss {
    public static void main(String[] args) {
        int t;
        int count=0;
        for(t=101;t<210;t++) {
            boolean f=true;
            int n=(int)Math.sqrt(t);
            for(int i=2;i<n+1;i++){
                if (t%i==0){
                    f=false;
                }
            }
               if(f) {System.out.println(t);
               count++;}
               else continue;
            }
        System.out.println(count);
    }
}

5.3 数组

数组是引用对象类型，其声明不能创建对象本身，而是创建一个引用，由new语句动态分配。

type [][]...arrayname;
//在创建时默认初值为0，也可以显式初始化
int[] a={1,2,3};
//数组的声明不能确定数组大小，实例化时才能分配
arrayName=new type [arraysize]
//多维数组从最高维开始，分别为每一维分配空间
String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

• 字符串：不是char类型的一维数组，不存在’\0’结束符；

char[] data="Car".toCharArray();
//则data={'C'，'a','r'};字符串转char

获取多维数组长度：

int  [ ] [ ] array = { {1 ,2,3},{4,5,6},{7,8,9}} ;
int rows = array.length ;
int columns = array[0].length ;

6 异常

• 程序执行过程中出现的不正常现象叫做异常（非预期情况、错误参数、网络故障），发生异常时，系统抛出一个异常对象封装出错信息，JVM捕获这个异常并且显示在终端。
• 异常处理关键字：https://blog.csdn.net/weixin_42621338/article/details/82721476
  （注意catch处理时必须子类在前父类在后，不然子类没处理）（throws方法声明时抛出）(throw手动抛出异常）
  
  
  
  
  
  
  
  

7 输入输出流

7.1 定义和分类

• 1.定义：为屏蔽不同外设的差异，java用java.io包实现上层软件与硬件的隔离，用流（计算机的输入输出间运动的数据序列，可以是文件内存或者网络连接等，形式为二进制或者其他编码，所有流的行为具有相同方式）抽象地将产生数据的源和适用数据的目的联系。计算机从输入流读取数据，将结果写入输出流（两者分别只能读和只能写）
• 2.分类方式：
  流的另外一种分类按照读写的操作单位分为字节流（byte stream,以单字节或者字节组读写）和字符（character stream，以单字符或者字符块为单位）流。（在最底层其实都是字节流，但基于字符的流未处理字符提供方便有效的方法）
  再另外一种按照逻辑划分为节点流(node stream 直接从指定位置读写），其他的称作过滤器（filters 输入流一般来于其他输入流，处理后再输给其他）

7.2 文件

• 类File提供了一种与机器无关的方式来描述一个文件对象的属性，能独立于平台处理文件。
  File类 主要方法：

1.文件路径和属性：getPath() /getName()/
2.创建目录和删除文件：mkdir()创建文件目录，delete()删除文件或目录，删除时需保证所删的是一个空目录。
3.文件更名：rename To(“newname”)给文件和目录更名；equals()判断两个File对象是否相等。
4.目录清单：list()返回目录所含文件名，子目录名；

RandomAccessFile类：

这里是引用