前言

​ 上课记录的零碎的java知识，之后会出一个总的详细的java入门笔记。

方法格式

[修饰符] 数据类型 方法名称（[参数]）{
    变量
    语句
}
//修饰符:
1.表示访问范围的
    public private protected 省略
2.static 静态的 类的 实例的
(1)类的方法可以直接调用，实例方法需要先定义变量，然后通过变量再调用
直接调用：
Math.abs(xx)    Math.sqrt(x)    Math.round()
System.out.print() 
Scanner.nextlnt()
间接调用：
Scanner in =new Scanner(System.in)
    x=in.nextlnt()
(2)内存的存储方式不一样
static变量：类的所有实例共享内存空间
非static变量：类的所有实例有各自独立的内存空间
class Student{
/*static*/ String xh;
String xm;
}
//数据类型：基本 引用
1.如果方法不需要返回结果，数据类型为void，方法内不能有return语句
例如：
static void primestar(int a){
for(int i=0;i<a;i++)
    System.out.print("*");
} 
2.需要返回结果，返回结果的数据类型即方法的数据类型，该结果用return返回
//方法名称：符合命名规则的标识符
//参数
形式参数：定义方法时参数
实际参数：调用方法时传递给方法的数据
数据类型 参数名称 1，数据类型 参数名称 2
   形参作用范围在方法体内
   方法内的代码

方法声明

[修饰符] 返回值类型 方法名[(参数表)]
{
变量声明
语句
}
修饰符：范围 static
类的方法 类的变量
实例的方法 实例的变量
1.使用上的区别：类.方法()  对象.方法()
    实例的方法只能使用:对象.方法()
2.内存、生命周期
    类变量是所有的对象共享一个内存空间
    实例变量每一个对象有各自独立的内存空间
    
    方法返回值类型：
        基本类型、引用类型(数组、对象)
        return 表达式(数据类型)
        return的数据类型要与方法的返回值类型一致
        从低往高：自动转换
        从高往低：强制转换
        
    参数：可以有0到多个
        参数列表：形参 
        调用方法时传递给形参的数据：实参
        形参定义格式：数据类型 形参名称 1 ，数据类型 形参名称 2...
        int a,b,c;
        形参作用范围：方法内 
            生命周期：调用方法->方法结束
            形参使用同方法内声明的变量 
            调用方法时：实参传递给形参(形参的初始化)
        参数传递方式：值传递
        调用方式：
            1 表达式中(有返回值的)
            2 方法语句(void)
        递归方法：
            在方法内调用方法自身
        void test(){
            ...
            test();
            ...
            }   

数组

二维数组 
定义 数据类型 名称[][]  或  数据类型[][] 数组名称
初始化：1 new   例：int a[][]=new int[3][4] //3为行数，4为列数
       2 初始值表赋值 int a[][]={{1},{},{1,2},{1,2,3}};
基本操作：引用：
            元素引用（跟基本类型的变量等价）
            数组名引用（地址，不能更改）
            数组名（下标）->变量
        输入：
            for(int i=0;i<a.length;i++)
                a[i]=in.nextInt();
        输出：
            for(int i=0;i<a.length;i++)
                System.out.print(a[i])；
        二维：
            for(int i=0;i<a.length;i++){//外层循环
            //输出一行
                fot(int j=0;j<a[].length;j++)//内层循环
                    System.out.print(a[i][j]);
            //换行
                System.out.println();
                }
        复制：
        元素 数组名
        int a[]=new int[5];
        int b[]={2,4,6,8}
//第一种复制
    for(int i=0;i<b.length;i++)
        a[i]=b[i];
//第二种：数组名
    a=b;
存储数据：
int a[]=new int[10];

查找算法：
//顺序查找  
    int a[]={1,4,6,0};
    int x=in.nextInt();
    for(int i=0;i<a.length;i++) if(x==a[i]) OK;
//二分法(数列已经排序)
    int left,right,mid,x,index;
    int[] a;
    left=0;right=a.length-1;
while(left<=right){
    m=(left+right)/2;
    if(x<a[m]) right=m-1;
    else if((x>a[m]) left=m+1;
    else {index=m;}    
}

排序：算法复杂度：时间：大O表示法
               空间：小O表示法

面向对象的程序设计

输入  处理  输出
数据处理机+程序
数据类型：基本（数值 字符 布尔）
引用（数组 类）
类：一种数据类型    一种类型    某一类
int x;
x 代表某个内存
不同变量之间没有内存联系
定义一个平面上的点
点：x,y坐标
x1,y1  x2,y2
double[] x
double[] y

//在C中 结构体
struct Point{
    double x；
    double y;
}
struct Person{
    double h；
    String xm;
    struct Address{
    
    }
}
//在JAVA中 把原来C中的struct换成class 理解为把类定义成一种新的数据类型
class Point{
    double x；
    double y;
}
class Person{
    double h；
    String xm;
    class Address{
    }
}
/*调用时为*/
Point pt1;

/*又例如*/
class Triangle{
    Point pt1,pt2,pt3;    
}

/*
面向过程    面向对象
面向对象： 分析（OOA）   设计（OOD）     编程（OOP）
问题：所有对象->相似 有共同特性的对象->某一类（类）->相似的特性->某一类的上层类（父类）
定义：最上层开始->子类
使用：用类定义变量（对象）
↓
两类程序员：
定义类：属性 方法
使用类：

围绕人（程序员）  效率 成本
指令序列
指令  数据或地址,数据或地址...
代码重用
ctrl+c+v
函数（方法）
包含文件 
源代码级
权限是不能控制的*/

1.继承性
class Person{
    double h；
    String xm;
    class Address{
    }
}
class Student extends Person{ 
        //学生为子类，人为父类，Person中定义的内容就不必再Student中定义了
}
2.扩展性——用来实现代码重用
形状：面积   体积
三角形 圆形
形状 形状1 = new 三角形; 
形状1.计算面积;
形状 形状1 = new 圆形; 
形状1.计算面积;

也可以对运算符重新定义
3.多态性——体现灵活性

类中特殊的方法 —— 构造方法：类 变量=new 类的构造方法()
    构造方法：通过参数初始化类的成员变量
    名称跟类的名称相同
    public 构造方法名称(同类的名称)(形参)
    没有返回值（也不是void）
   可以有多个构造方法，用不同的参数区别（个数 顺序）
   如果没有定义，系统提供一个没有参数的默认构造方法
   不能显示调用
   Point pt1=new Point();
   

类的概念 面向对象的特点 类的声明 类的使用 构造方法

class 名称{
    数据(成员变量)；
    处理(成员方法);
}

类 变量(对象) =new 构造方法
变量 =new 构造方法
初始化：分配内存，初始化成员变量
对象.成员变量 成员方法

访问范围的修饰符

public——所有范围都可以访问；
private——类的内部可以访问；
protected，空的——类的继承关系 包

封装性：类的属性和处理是一个整体 可以控制访问

类 变量（标识符）=new 构造方法()
分配对象的内存空间，通过构造方法初始化成员变量。

对象的销毁：垃圾回收机制（消息机制） 当对象引用数为0，则告诉系统该内存可以回收了。

主动回收时（使用的对象没法通过垃圾回收机制自动处理时）：手动处理（null）

public void finalize(){
    手动处理
}
1.调用System.gc()启动垃圾回收时
2.结束运行时，会调用每一个对象的finalize()
3.显示调用
构造方法    析构方法
面向对象的特性一：封装性  /*内部可以修改，不改变外部输入内容*/
1、类的属性和方法是一个整体
2、类的属性和方法可以通过访问范围的修饰符控制访问权限，可以隐藏内部的实现细节。
接口：对象之间交互的方式。
类的位置：本类 同一个包的类  不同包的类
代码层级：
类：class  类名  文件系统：文件名.java
类名==文件名
一个原文件只能有一个public类

文件系统中包对应一个文件夹
包名==文件夹名

public:数据的逻辑校验、有效性校验跟问题(业务)相关时
1.获取数据；2.有效性检查(业务逻辑)；3.赋给对象的成员变量

private:数据具有一般性(普遍性)，跟具体的问题无关时
1.获取数据；2.赋给对象的成员变量

通过方法开放数据访问的接口（只读、只写、读写）

关键字：
static：静态的
类 static非static
类成员（有static修饰）
实例成员（无static修饰）

区别：
1.使用上

实例：
类 对象；
对象.成员
类成员：
（1）实例的方式引用
（2）类.类成员变量  类成员方法

2.内存分配
成员变量（数据）
实例成员变量：每一个对象拥有独立的内存空间
类成员变量：所有对象共享一个内存空间
3.语法规则
在static方法内不能直接调用非static成员变量或方法
实例方式

面向对象的封装性：权限修饰符
类的声明
类的成员变量：实例 类
构造方法
类的使用
[ public | 空 ] [final] class 类名{
}

一个文件中只能有一个类是public类型的，类名和文件名是相同的。
?final:表示这个类能不能被修改
程序运行期间能不能被修改：常量（直接常量；符号常量）；变量
符号常量定义：final

输入 处理 输出
处理：硬件+程序
程序：对象 搭积木

第七章 继承性和多态性
继承性：重用
1、 ctrl+c ctrl+v
2、函数（方法）
3、文件（包含文件include文件） 源代码级
4、模拟生物的遗传特性（继承）

实例1：
学生类：学号 专业 学校名称...

特殊学生：获奖 特长

处理方式一：
定义一个新的学生类型：包含所有需要的数据
处理方式二：
在学生类的基础上定义一个新的类

继承：定义的新的类派生于已经存在的类
已经存在的类派生一个新的类

已经存在的类：
父类 基类 超类
新的类：
子类 孩子 孙子类

JAVA中所有的内容都是类（对象）

设计类的时候需要考虑：

1. 有哪些数据（属性）
2. 有什么处理（方法）
3. 调用权限（公开的，私有的，受保护的，缺省的）

UML : 通用建模语言

定义子类派生于已经存在的父类
可以继承父类的：
1.可以继承变量、方法（不能继承构造方法）
2.可以修改变量、方法（覆盖）
3.可以新增变量、方法

区别子类和父类的相同方法：
1、使用类的时候调用的是哪个方法
2、在子类内部调用时怎么区别

class Test{
}

缺省从object中继承
toString
equal
Test t=new Test();

this：本类的变量、方法等
class Test{//没有定义构造方法}
Test t = new Test();

查找路线：本类-》父类-》祖父类-》直到object
关键字：super this（super只能在子类中使用）
super：父类的变量、方法、构造方法
this： 本类的变量、方法、构造方法
只能在类内部使用
super.父类方法
super.父类变量

派生子类时，子类不需要初始化父类的变量

派生的子类，必须通过super去调用父类带参数的构造方法

class Child extends Test{
public Child(int x,int b)
//初始化
super(x); //初始化父类
//初始化本类的变量
}

增加新的功能时：
1、代码的修改量
2、修改的难度（对已有代码的影响）

传统的函数、文件：不能存在同名的函数

多态性：扩展
代码可以有多个同名的方法，有不同的实现（功能），通过不同的参数（个数、类型、顺序）区别

public void test();
public void test(int a);
public void test(int a,int b);
public void test(String a);

错误：
public void test(int a,int b);
public void test(int b,int a);

正确:
public void test(int a,String b);
public void test(String a,int b);

同一个类的多个同名方法：重载
例如：构造方法
子类和父类有同名方法：覆盖

/*问题：计算不同形状的面积*/
圆形 长方形 正方形 三角形

C语言中：areaCircle areaRect areaSquare
JAVA:
同一个类中
不同形状定义各自的类
//方法一
class Shape{
    final double PI=3.14;
    public double area(double r){
        return PI*r*r;
    }
    public double area(double a,double b){
        return a*b;
    }
    public double area(double a){
        return a*a;
    }
}

//方法二
class Shape(){
    final double PI=3.1415;
    public double area(){
    return 0;
    }
}
class Circle extends Shape{
    double r;
    public Circle(double r){
        this.r=r
}
    public double area(){
        return PI*r*r;
    }
}
class Square extends Shape{
    double a;
    public Square(double a){
    return a*a;
    }
}

/*调用时*/
//1.一般使用方式
Circle c1=new Circle(3);
Square s1=new Square(3);
//2.用父类定义变量，初始化成子类的对象
Shape s2=new Shape();
s2=new Circle(3);
System.out.print(s2);
s2=new Square(3);
System.out.print(s2);

抽象类、接口：抽象方法
1、统一子类方法名称；
2、不能实例化；
3、接口实现了设计与实现分离；
4、提高开发效率

抽象类 对象=new 抽象类() X
√：抽象类 对象=new 子类()

关键字：abstract
抽象方法：只有方法头，没有实现体（方法体）的方法

abstract class Shape{
    public final double PI=3.14;
    public abstract double area();
    public abstract double volume();
}
//继承了抽象类的子类要提供父类中抽象方法的实现体
class Circle extends Shape{    
}

接口
JAVA的安装文件格式
jar：压缩文件（使用时调用jar中的文件）

package pack; //包的声明
import *.*;   //包的导入

异常处理

1.语法错误：不能运行
2.逻辑错误：能运行，结果不正确（表达式不正确）
3.异常Exception：编译阶段 运行阶段
异常：程序能运行，结果正确，在特殊数据或条件下，程序会出现不可挽回的错误（崩溃）
手动编译时异常：类找不到 方法找不到
系统定义的运行时异常：算术运算（被0除） 下标越界 数据转换时类型不匹配

处理异常的目的：提高程序的稳定性 出现异常时给出用户友好的提示
异常处理方法：避免if 捕获异常try...catch块结构

对已知异常的处理：
Exception 类 子类：
{
2个构造方法
2个返回字符串信息的方法
toString(） 返回描述性的信息
getMessage() 放回错误编号
}

异常处理

捕获异常

try{
    System.out.println(args[2]) 
        /*可能出现异常的代码
        打开文件
        数据读写
        关闭文件*/        
}catch(Exception e/*异常类  对象*/){
    System.out.println(e.getMessage())  
        /*给出自己的提示信息*/
}
[
    finally{
        /*必须执行的代码：
            手动释放内存
            关闭文件
            关闭数据库连接*/
    }
]

业务抛出异常

业务逻辑、数据有效性检查

score
if(score>100||score<0)
    通用提示；
if(score<0||score>100)
    抛出异常;
    
/*在其他位置捕获这个异常 给出相应的提示*/
语法：
throw new 异常类()     //使用该类的默认信息
throw new 异常类(信息)       //用户定义的信息
信息 -> getMessage()

//自定义异常类:用Exception
    class MyExcp extends Exception{
        
    }

输入/输出类库

字节流
字符流：字节流处理后的结果
data——>缓冲（如flush()等）——>File

System.out.方法
System.in.方法
Scanner in = new Scanner(System.in）

设备 ：file
管道符：
java add <data >

java add
1 2
3

文件操作的流程：
1 打开文件 ，返回文件对象（文件对象的指针）
2 文件读写操作
3 关闭文件

打开文件：
1 创建一个File对象
2 创建一个流对象（File对象）

直接创建一个流对象(文件名)

File(String path)
File(String path, String filename)
File(File dir, String filename)
File 对象包含了所有跟文件、文件夹有关的属性和操作
path：全路径

相对路径
Windows：盘符:\文件夹\文件夹\文件名.扩展名
例如：d:\test\pack\data.txt
Linux：/文件夹/文件夹/文件名 例如： .. 指上一层目录

Applet

浏览器：解释器 JVM
html：标签+内容+样式+js脚本
动态的：服务端通过程序产生网页内容

<html 属性>内容 </html>

浏览器对客户端的权限很低
浏览器插件（扩展件）
安装JRE

applet与一般程序的区别：

• 运行方式：浏览器运行
• 开发人员：ide appletviewer 页面.html

Applet的代码：
从JApplet类派生子类：
init：初始化，加载各种组件
start：激活页面，窗口还原
stop：失去焦点，窗口最小化
destroy：关闭页面
paint：通过画图的方式输出内容时

import
    class 类名 extends JApplet{
     paint(Graphics g){
         g.drawString("hello applet",x,y);
     }   
    }

jar
<applet code="app/helloapplet.class" width="" height=""/>

test.html
app/helloapplet.class

多线程

程序 进程 线程
OS：进程管理正在运行的程序
进程包括代码、数据、管理进程需要的信息PID
分配CPU内存资源
休眠、恢复、暂停
单进程 多进程
单线程 多线程

作用：
1 多用户使用——并发
2 把一个任务分解成多个子任务（提高效率）

多进程和多线程的区别：
1 进程是OS管理 线程是程序管理的
2 通信方式不一样
线程间可能通过进程共享（多个对象可以通过类成员变量共享数据）
3 线程可以理解为一种轻量级的进程

多线程应用：改进用户交互
pi：100W
计算密集 CPU
100%CPU 200s 5m
主线程：用户交互（优先级高）
其他线程：计算（优先级低）

java的main是主程序的线程
JOptionPane.showInputDialog()
1 一种一些图形组件自动增加新的进程
2 程序中创建线程对象

从Thread类派生一个子类
start() run() 相当于主线程的main方法，是线程执行的入口
stop() destroy() 结束线程
实现Runnable接口
run()

线程的状态：
新生（创建start） 就绪 运行 阻塞 结束

thread.join():
当有多个线程的运行需要先后顺序时，调用join方法，会等当前线程执行结束后再启动后面的线程。

Thread ta;
Thread tb;
ta.start();
tb.start();

//正确的方法
ta.start();
ta.join();
tb.start();

线程同步

图形用户界面

AWT组件

消息——>OS——>APP——>组件
事件——>组件_方法
考试常考：选择题中会出现画图

Swing组件

复习课

数值转换 —— 利用编码值进行判断

x *= y+3    //等价于 x = x*(y+3)

三目运算符——类似于选择结构

排序算法 冒泡排序 二分法(考的可能性小)