Java程序设计大纲

本文最后更新于:2021年3月22日 下午

学习 JAVA 程序设计时提炼的大纲,供大家学习

Java程序设计大纲

JAVA的运行原理和跨平台

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

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

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

(java代码编译后不能直接运行,它是解释运行在JVM上的)

Java的语言的特点

  • Java是纯面向对象的语言

  • 平台无关性

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

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

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

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

  • 程序严谨整洁

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

面向对象

三种典型

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

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

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

对比面向过程

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

Java的基本数据类型

  • 位数确定,不因为操作系统不同而不同
  • 所有基本类型的关键词都是小写
基本类型 大小(bits) 范围
char 16 021610\sim2^{16}-1
byte 8 128127-128\sim127
short 16 2152151-2^{15}\sim2^{15}-1
int 32 2312311-2^{31}\sim2^{31}-1
long 64 2632631-2^{63}\sim2^{63}-1
float 32 -
double 64 -

判断对象相等

  • =:

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

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

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

    • 对象判等,需要重写 equal 函数
  • equal():

    • 重写equl:
    1. 先用“==”判断是否相等

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

    • 如果为 null,则返回 false;因为当前对象不可能为 null,如果为 null,则不能调用其 equals() 方法,否则抛 java.lang.NullPointerException 异常。
    • 当参数不为null,则如果两个对象的运行时类(通过 getClass() 获取)不相等,返回 false,否则继续判断。
    1. 判断类的成员是否对应相等。
    • 实例
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中语句执行完成后返回
      任何执行try或者catch中的return语句之前,都会先执行finally语句,但是return表达式的值会被计算出来,但是不会返回。如果finally语句存在的话。如果finally中有return语句,那么finally中的return是一定会被return的

本博客所有文章除特别声明外,均采用 CC BY-SA 4.0 协议 ,转载请注明出处!