Java期末复习笔记

0x01 Java语言基础知识

标识符

第一个字符必须是字母、_或$，后面的字符 可以是字母，下划线，$或数字。

类型转换

Java中数据的基本类型（不包括逻辑类型）按精度从低到高排列：

byte short char int long float double

★自动转换：当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换。

例： float f =5；

★强制转换：当把级别高的变量的值赋给级别低的变量时，必须使用显示类型转换运算。

显示转换的格式：（类型名）要转换的值; （低）高

例：float h =5.21f; 
       int a=(int)h；

0x02 类与对象

类的声明格式

[public][abstract | final] class classname[extends father_class] [implements interfaces_name]
{
	//变量成员声明及初始化
	//方法声明及方法体
}

注：每个编译单元(文件)只能有一个public类。即每个编译单元只能有一个公开的接口。public类的名字必须和这个编译单元的文件名完全相同。

定义方法的格式

[public | protected | private][static][final][abstract][native][synchronized] 
返回类型 function_name(argv[0] value0,[argv[1] value1...]) [throw exception1,exception2...]
{
	方法体
}

在静态方法中只能直接调用静态变量，静态方法或对象的属性和方法，不能直接使用非静态方法和非静态变量

包的概念

1.用import导入外部的类、同一个包中的类不需要import
关键字顺序：package import class

类的访问权限

• 要修改private变量只能通过添加set和get方法得到

方法重载

跟成员方法一样，构造方法也可以重载。

声明为final的方法不能被重载。
声明为static的方法不能被重载，但是能够被再次声明。

方法重载的规则：
方法名称必须相同。
参数列表必须不同。（包括：个数不同、顺序不同、类型不同。）
方法的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以称为方法的重载。

传值

if(形参= =基本类型) 实参值复制给形参。
if(形参= = 对象) 对象的引用（地址） 给形参。
（java传object都是引用）

例如，下列的【代码2】

class Fish {
   int weight = 1;
}
class Lake {
   Fish fish;
   void setFish(Fish s){
       fish = s;
   }
   void foodFish(int m) {
      fish.weight=fish.weight+m;
   }
}
public class Main {
   public static void main(String args[]) {
       Fish  redFish = new Fish();
       System.out.println(redFish.weight);  //【代码1】  //1
       Lake lake = new Lake();
       lake.setFish(redFish);
       lake.foodFish(120);
       System.out.println(redFish.weight);  //【代码2】  //121
       System.out.println(lake.fish.weight);  //【代码3】  //121
    }
}

this关键字

1. 可以使用this关键字在一个构造方法中调用另外的构造方法
2. 对this的调用必须是构造函数中的第一个语句
3. 通常用参数个数比较少的构造方法调用参数个数最多的构造方法
4. 通常也用在区分本类中的参数与引用的参数（当变量名相同时）

0x03 继承、抽象、组合

子类的继承性

1. 子类父类在同一包中 ：只要不是private，都可继承。（访问权限保持不变）

2. 子类父类在不同包中： 只继承 protect 和public.

instanceof运算符

x instanceof A：检验x 是否是类A的对象，返回值是Boolean。

判断是否 是类A的对象的依据： 创建x的类是否 是类A 或者是否 是类A的子类

if(是) return true；
else return false；

属性隐藏，方法覆盖

1. 属性的隐藏：子类中声明了与父类相同的成员变量名，则从父类继承的变量被隐藏。可以利用super.属性（方法）访问被隐藏的父类属性和方法。是针对于成员变量和静态方法而言的
2. 方法的覆盖：覆盖方法的返回类型，方法名称，参数的个数及类型必须和被覆盖的方法一摸一样，是针对于实例方法而言的
   ==注：有抽象类必有覆盖方法，final和static方法不能被覆盖，若父子有同为static方法则为隐藏
   ==

终结类与终结方法

定义：被final修饰符修饰的类和方法

1. 终结类不能被继承
2. 终结方法不能被当前类的子类重写

抽象类，抽象方法

抽象类

1.abstract类可以有abstract方法，也可以有非abstract方法（但是非abstract类 不能有abstract方法）.
2.不能被实例化，必须有子类覆盖其声明的方法

抽象方法

1.对于抽象方法，只允许声明，不允许实现
2.不允许使用 final和abstract同时修饰一个方法或类。
3.不允许用static修饰abstract方法，即abstract方法 必须是实例方法。

---

---

0x04 接口与多态

• 先继承 后实现： class A extends B implement C,D,E
• 接口声明： interface xxx
• 接口体 ：接口体里只有常量，抽象方法 ，没有普通方法和变量。
  1. 常量：public static final int Max =100； （public static final 可省略）
  2. 抽象方法 ：public abstract void f(); (public abstract 可以省略)

类型转换

• 隐式的类型转换

//被塑性成更一般的类
Employee emp;
emp = new Manager();//将Manager类型的对象直接赋给Employee类的引用变量，将Manager对象塑性为Employee类

//被塑性为对象所属类实现的接口类型
Car jetta = new Car();
Insurable item = jetta;

• 显式的类型转换

//基本数据类型
(int)871.34354;  //871
(char)65;//'A'
(long)453; // 453L

//引用变量：还原为本来的类型
Employee emp;
Manager man;
emp = new Manager();//将Manager向上塑型为Employee，此时emp中如果有被重写的方法，则调用Manager类中的方法，但此时不能调用Manager类中的特有方法
man = (Manager)emp;//将Manager还原回去，此时可以调用Manager类中的特有方法
//在向上和向下的塑型过程中一直只有一个Manager被转换，不能转换为Employee的其他子类，只能向下塑型回Manager类

0x05 内部类 ，异常处理

内部类和外嵌类的重要关系

1. 外嵌类的成员变量在内部类中仍然有效，内部类的方法 也可调用外嵌类的方法。（也就是说，内用外：随意。）
2. 内部类不可以声明类变量，类方法。
3. 外嵌类可以用内部类声明对象，作为外嵌类的成员。
4. 内部类仅提供它的外嵌类使用。

0x06 常见实用类

String

• 双引号括起来的字符串 是不可变的。（都在常量池里有一份）
  （new 会在堆里开辟空间）
  
  

String的构造方法

1. String(String s) :

     String x = new String(s);
   

2. String(char a[])

    char a[] ={'b','c'};
    Srtring s= new String(a);
   

3. String(char a[],int startIndex，int count)：

    char a[] ={'0','1'.'2','3','4'};
    String s = new String(a,1,3);   //"123"
   

String的常用方法

1. public int length()

    String  a =" hello";
    int n1,n2;
    n1=a.length();  // 5;
    n2="全场carry".length(); // 7
   

2. public boolean equals(String s)

    String s="xxx",r="yyy";
    boolean f = s.equals(r);   //  return false
   

3. public boolean startsWith(String s) , public boolean endWith(String s)

    String s ="B站关注帅小柏";
    boolean n1,n2;
    n1= s.startsWith("B站");  // true
    n2 = s.endWith("小柏");  // true
   

4. public int compareTo(Srting s)

0x07 IO流（java.io包）

0x08 组件及事件处理（GUI）

0x09 JDBC

JDBC六步走（基本步骤）

1. 注册驱动（告诉java程序，即将要连接的是哪个品牌的数据库）
   

2. 获取连接（表示JVM的进程和数据库的进程之间的通道打开了）
   

3. 获取数据库操作对象（专门执行SQL语句的对象）
   

4. 执行SQL语句（DML,DQL…）
   

5. ** 处理查询结果集**(只有当第四步使用的是select语句的时候，才会有第五步处理查询结果集)

6. 释放资源（使用完资源一定要关闭，java和数据库之间属于进程之间的通信，一定要关闭）

代码实现

import java.sql.*;

public class Main {
    public static void main(String[] args) {

        String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver";

        String dbURL = "jdbc:sqlserver://localhost:1433;DatabaseName=每日一题";

        String userName = "sa";

        String userPwd = "atsj*******"; // 保密

        Connection conn = null;
        Statement sta = null;

        try {
            // 1.注册驱动
            Class.forName(driverName);
            // 2.获取连接
            conn = DriverManager.getConnection(dbURL, userName, userPwd);
            // 3.创建statement对象
          sta = conn.createStatement();
           // 4。发送SQl
            String sql ="delete from stu where sname = '傻桃'";
            sta.executeUpdate(sql);
            System.out.println("连接数据库成功");

        } catch (Exception e) {

            e.printStackTrace();

            System.out.print("连接失败");

        } finally {
            if (sta != null) {
                try {
                    sta.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }

        }


    }
}

0x10 多线程

创建线程的方法

1 继承 Thread

package Mythread;

public class Main extends Thread{



    public static void main(String []args){
         Main m = new Main();
         m.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("maining------"+i);
        }

    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("runing"+i);
        }
    }
}

2 实现 Runnable接口

package Mythread;

public class Main implements Runnable{



    public static void main(String []args){
         Main m = new Main();
         new Thread(m).start();
        for (int i = 0; i < 100; i++) {
            System.out.println("maining------"+i);
        }

    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("runing"+i);
        }
    }
}

1.3 实现 Callable 接口 （了解即可）

0x11 网络编程

TCP

代码实现步骤

• 客户端的实现
  

• 服务器的实现

0x12 泛型编程

0x13 图形，图像与音频