Java程序设计备忘

本文最后更新于 2023年3月3日 下午

学习 Java 程序设计时提炼的备忘，供大家学习

Java 程序设计备忘

Java 的运行原理和跨平台

  • 编译型语言：把做好的源程序全部编译成二进制代码的可运行程序。然后，可直接运行这个程序。

（经过一次编译之后,可以由操作系统直接执行）

  • 解释型语言：把做好的源程序翻译一句，然后执行一句，直至结束。

（Java 代码编译后不能直接运行，它是解释运行在 JVM 上的）

Java 的语言的特点

  • Java 是纯面向对象的语言

  • 平台无关性

借助Java虚拟机，可以做到一次编译，到处运行

  • Java 提供了丰富的内置的类库

  • Java 语言提供了 Web 应用开发的支持

  • Java 语言具有良好的安全性和健壮性

  • 程序严谨整洁

  • Java 的强类型机制，垃圾回收器，异常处理，安全检查机制使得java语言编写的程序有更好的健壮性和鲁棒性

面向对象

三种典型

  • 封装：把客观事物封装成抽象的类。隐藏属性和方法的实现细节，仅对外公开接口

  • 继承：子类可以使用父类的所有功能，并且对这些功能进行扩展。继承的过程，就是从一般到特殊的过程

  • 多态：接口的多种不同的实现方式即为多态。同一操作作用于不同的对象，产生不同的执行结果。在运行时，通过指向基类的指针或引用(Java 只能是引用)来调用派生类中的虚函数来实现多态

对比面向过程

面向对象更加封闭也更安全，思维方式也更加贴近现实生活。

Java的基本数据类型

  • 位数确定，不因为操作系统不同而不同
  • 所有基本类型的关键词都是小写
基本类型大小(bits)范围
char160∼216−10\sim2^{16}-1
byte8−128∼127-128\sim127
short16−215∼215−1-2^{15}\sim2^{15}-1
int32−231∼231−1-2^{31}\sim2^{31}-1
long64−263∼263−1-2^{63}\sim2^{63}-1
float32-
double64-

判断对象相等

  • =：

    • java 中的基本数据类型判断是否相等，直接使用“==”就行了，相等返回 true，否则，返回 false

    • 对象的==表示引用变量指向的内存是否相同

    假设有两个引用对象 obj1、obj2。obj1==obj2 判断是 obj1、obj2 这两个引用变量是否相等，即它们所指向的对象是否为同一个对象

    • 对象判等，需要重写 equal 函数

  • equals() ：

  1. 先用“==”判断是否相等

  2. 判断 equals()方法的参数是否为 null：

    • 如果为 null，则返回 false；因为当前对象不可能为 null，如果为 null，则不能调用其 equals() 方法，否则抛 java.lang.NullPointerException 异常。

    • 当参数不为 null，则如果两个对象的运行时类（通过 getClass() 获取）不相等，返回 false，否则继续判断。

  3. 判断类的成员是否对应相等。

  • 实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Dog {
    private int age;
    private String name;
    public Dog(int age,String name){
        this.age=age;
        this.name=name; 
    }
    @Override
    public boolean equals(Object obj) {
        if(obj==null){ return false;}
        if(this==obj){ return true;}
        if(obj instanceof Dog){
            Dog dog=(Dog)obj;
       if(dog.age==this.age&&dog.name.equals(this.name)){
                return true;
            }else{
          return false;
            }
        }
        return false;
    }
    public static void main(String[] args){
        Dog dog1=new Dog(12,"wangcai");
        Dog dog2=new Dog(12,"wangcai");
        Dog dog3=new Dog(16,"wangcai");
        System.out.println(dog1.equals(dog2));//true
        System.out.println(dog1.equals(dog3));//false
     }

  • Java字符串判断相等

    • 字符串相等用 equals() 方法

    实例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class StringEquals {
     public static void main(String[] argv) {
      String s1=new String("Hello"); 
      String s2=new String("Hello");
      if(s1==s2) {
       System.out.println("== true");
      }
      else{
       System.out.println("== false");
      }
      if(s1.equals(s2)) {
       System.out.println("equals true");
      }
     }
    }
    输出结果：
    == false
    equals true

初始化

  • 显式静态：
    Java允许多个静态初始化动作组织称一个特殊的“静态语句”

    • 和其他静态初始化动作一样，该段代码仅执行一次

    • 首次生成这个类的一个对象或者首次访问那个类的静态数据成员（即便从未生成过那个类的对象）时

    • 加上static关键字

      • static修饰的语句或变量的特点有：
        　　1. 随着类的加载而加载
        　　2. 优先于对象存在
        　　3. 为所有的对象共享
        　　 4. 可以使用类名调用，即类方法

  • 非静态实例的初始化：

    • 实例初始化的语句在构造函数之前执行

  • 总结：
    拿单个的类来讲，执行顺序是 静态初始化块 -> 初始化块 -> 构造器

我们知道，当子类继承父类时，执行顺序是先执行父类，再执行子类。根据上述的顺序，我们可以得到如下的执行顺序：
1. 父类静态初始化块
2. 子类静态初始化块
3. 父类初始化块
4. 父类构造器
5. 子类初始化块
6. 子类构造器

  • 实例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class A {
    public A() {
        System.out.println("class A");
    }
    { System.out.println("I'm A class"); }
    static { System.out.println("class A static"); }
}
public class B extends A {
    public B() {
        System.out.println("class B");
    }
    { System.out.println("I'm B class"); }
    static { System.out.println("class B static"); }
     
    public static void main(String[] args) {
        new B();
    }
}

输出结果：
class A static 
class B static 
I'm A class 
class A
I'm B class 
class B

继承

  • 继承使用 extends 关键字
  • 被继承的类称为父（超类），新类叫做子类
  • 使用继承时，子类会得到父类所有的域和方法
  • 继承并不是复制基类的接口
  • 使用 super 表示父类

组合与继承

  • 组合关系（本质是“has-a”关系）
    组合其实是使用程序的代码，而非使用其形式
  • 继承关系（本质是“is-a”关系）
    继承保留原有代码的结构基石，在上面进行特性化补充

多态

向上转型

新类和基类的关系可以用“新类是现有类的一种类型”概括
可以将子类的对象赋值给父类的引用，称为向上转型

网络

网络编程的实质就是设备(例如计算机)之间的数据传输
网络中包含的设备有：计算机、路由器、交换机等等
网络是分层的
七层参考模型和协议对应的关系
网络层   ----- IP（网络之间的互联协议）
传输层   ----- TCP（传输控制协议）、UDP（用户数据报协议）
应用层   ----- Telnet（Internet远程登录服务的标准协议和主要方式）、FTP（文本传输协议）、HTTP（超文本传送协议）

OSI参考模型TCP/IP
应用层
表示层应用层
会话层
传输层传输层
网络层网络层
数据链路层数据链路层
物理层物理层

构造函数调用的优先级

  • 调用静态对象的构造函数

  • 调用基类的构造函数

  • 构造层次结构的根，然后一层层的，直到最上层

  • 如果构造函数内部存在覆盖的方法，则调用覆盖后的方法

  • 按照声明的顺序调用成员的构造函数

  • 调用子类的构造函数

抽象类

和接口区别

  • 抽象类中可以有非抽象方法，接口中则不能有非抽象方法。

  • 接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法。

  • 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

  • 接口可以省略 abstract 关键字，抽象类不能。

  • 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

异常类

创建自定义异常

关键是继承和抛出操作

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class SimpleException extends Exception {}
public class InheritingExceptions {
  public void f() throws SimpleException {
   System.out.println("Throw SimpleException from f()");
   throw new SimpleException();
  }
  public static void main(String[] args) {
   InheritingExceptions sed = new InheritingExceptions();
   try {
    sed.f();
   } catch(SimpleException e) {
    System.out.println("Caught it!");
   }
  }
}
输出结果：
Throw SimpleException from f()
Caught it!

throw：就是自己处理一个异常，有两种方式要么是自己捕获异常 try...catch 代码块，要么是抛出一个异常（throws 异常）

throws 在方法后边声明异常，其实就是自己不想对异常做出任何的处理，告诉别人自己可能出现的异常，交给别人处理，然别人处理

多线程

进程和线程的区别

  • 线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位

  • 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线

  • 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号)，某进程内的线程在其它进程不可见

  • 调度和切换：线程上下文切换比进程上下文切换要快得多

  • 线程也叫“轻量级进程”

Java实现多线程的方法

  • 继承 Thread 类，重写该类的 run() 方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class MyThread extends Thread {
    private int i = 0;
    @Override
    public void run() {
        for (i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
}
public class ThreadTest2 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
            if (i == 3) {
                Thread myThread1 = new MyThread();     
                Thread myThread2 = new MyThread();    
                myThread1.start();                    
                myThread2.start();              
            }
        }
    }
}
  • Runnable 实现接口，重写 run() 方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class MyRunnable implements Runnable {
 @Override
 public void run() {
  // TODO Auto-generated method stub
   for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+" "+i);
         }
 }
}
public class ThreadTest {
 public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+ " " + i);
            if (i == 5) {
                Runnable myRunnable = new MyRunnable(); 
                Thread thread1 = new Thread(myRunnable);
                Thread thread2 = new Thread(myRunnable);
                thread1.start(); 
                thread2.start();
            }
        }
    }
}
  • synchronized 关键字可防止代码的关键代码段一次被多个线程执行。如果应用于静态方法，那么，当该方法一次由一个线程执行时，整个类将被锁定。

标识符

  • public protected friendly private
作用域当前类同一package子孙类其他package
public√√√√
protected√√√×
friendly√√××
private√×××

默认的是 friendly

  • 在一个 *.java 的文件中，只能有一个 public class 的声明，但是允许有多个 class 的声明；public class类名必须与文件名一致

    1. 不管有没有出现异常，finally 中的语句块都会执行，finally 语句通常用来释放资源，关闭数据库，
      关闭文件等操作
    2. 当 try 和 catch 中出现 return 时 finally 仍然会执行
    3. finally 是在 return 后面的表达式之后执行的。此时并没有将值返回，而是将数据保存在局部变量中，待 finally 中语句执行完成后返回
    4. 任何执行 try 或者 catch 中的 return 语句之前，都会先执行 finally 语句，但是 return 表达式的值会被计算出来，但是不会返回。如果 finally 语句存在的话。如果 finally 中有 return 语句，那么 finally 中的 return 是一定会被 return 的
备忘
#编程 #Java
Java程序设计备忘
https://justloseit.top/Java程序设计备忘/
作者
Mobilis In Mobili
发布于
2020年1月12日
更新于
2023年3月3日
许可协议