不系统化记录整理
只记下自己不熟悉的小知识点

OOP 类与对象

内聚性好，松耦合
侧重于功能（面向对象侧重于流程）
类是对象的抽象，对象是类的实例

继承Heritage 代码重用可拓展
多态 Polymorphism 统一接口
封装 Encapsulation 模块化隐藏细节

引用类型

对象、数组都是引用数据类型。
引用类型变量在声明后必须通过实例化开辟数据空间，才能对变量所指向的对象进行访问

City wf = new City(“Winterfell");
Int[] fibonacci = {1, 1, 2, 3, 5, 8}

for循环遍历

int[] numbers = {1, 2, 3, 4, 5};
for(int x : numbers){
  System.out.print(“value of x : “ + x + “\n");
}

创建对象

声明对象名称、类型
实例化用new
初始化构造方法——一个类可以有多种

封装 Encapsulation

实现模块化用getter setter
减少复杂度减少代码的耦合

private: 只能被该类的对象访问。
default: 即不加任何访问修饰符，只允许在同一个包中进行访问。
protected: 只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
public：不仅可以跨类访问，而且允许跨包（package）访问。

一个源文件中只能有一个public类;
源文件的名称应该和public类的类名保持一致;
如果一个类定义在某个包中，那么package语句应该在源文件的首行;

package animals; 
import java.io.*;

继承 Heritage

泛化/特殊化
代码的重用，使系统变得容易扩展
子类继承了父类中所有非private成员方法（除了构造方法）和所有非private的成员变量。
强耦合关系，在一定程度上破坏了封装，父类变化了，子类也随之变化；

子类初始化

当我们需要调用父类的构造方法时，只需使用super()即可
创建子类对象实例时，Java默认地首先调用父类的无参数的构造方法，生成父类的对象。接下来完成调用子类的构造方法，生成子类的对象。
使用了super，那么在执行的时候就寻找该构造方法，而不再寻找父类的无参数构造方法。
super必须作为构造方法的第一条执行语句

覆盖 override
同名又同参，又同返回值（一模一样）
子类与父类中出现
重载 overload ……返回类型可以相同也可以不同
同名不同参
可在同一个类中出现

final

final 关键字声明类可以把类定义为不能继承的，即最终类；
或者用于修饰方法，该方法不能被子类重写

上转型对象

上转型对象可以操作被子类继承和重写的方法，
但不能操作子类新增的成员变量和方法。
问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型，则继承是必要的，但是如果不需要，则应当好好考虑自己是否需要继承。

抽象类

具体类：可以被实例化的类
抽象类：不能被实例化的类
定义抽象类的基本目的是提供合适的超类，使其他类可以继承它，以实现共享。

抽象方法只包含一个方法名，而没有方法体
public abstract class Form{   
  private int posX;   
  private int posY;      
  public void getInfo(){     
    System.out.println(“This is a 2D form.”);   
  }
  …   
  public abstract void draw(); 
}

抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

静态变量、方法 static

静态变量在程序初始化时被创建，可被该类所有的实例使用和修改；

public static 数据类型 变量名; 
 
public static 返回值数据类型 方法名[形式参数列表]{ 
 
}

main()也是一个静态方法；

接口 interface

接口提供了一组功能的命名集合
接口定义了不同类交互的标准

[public] interface 接口名 [extends 其他的接口名列表] 
{
    [public static final] 数据类型 常量名 = 值;
    [public abstract] 返回类型 方法名（形参列表）; 
}

变量—— 只能是public static final（用 private 修饰会报编译错误）（类属性、不可被改变）
接口中的方法会被隐式的指定为 public abstract ——不能有静态方法
一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。不必使用abstract关键字，自动认为是抽象。抽象类可以有给出的方法
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

[访问修饰符] class 类名 [extends 超类名] implements 接口名列表 {
        类体 
}

类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
instanceof

public interface Comparable {
    public int compareTo(T o);
 }

public class Person implements Comparable {
  int age;  
  public int compareTo(Person p) {
      return this.age-p.getAge();
   }
 }
可以通过Collections.sort或Arrays.sort进行自动排序

多态 Polymorphism

多态就是指一种名称定义不同的方法
向上转型！编译时检验父，实际运行时才有可能调用子，然后才发现问题出错。

数组&实例

Cat[] cats = new Cat[10];  
for(int i=0; i


要每一个都实例 cats[i] = new Cat(“Kitty”, 100);
类的关系与UML图
类的关系
1+3+1
 继承 Inheritance

依赖Dependency
 方法中使用到、局部变量、对静态方法调用
关联 Association
 ⼀个类作为另⼀个类的成员变量出现
聚合 Aggregation
 是整体与部分之间是可分离的
 他们可以具有各⾃的⽣命周期
组合 Composition
 整体与部分之间是不可分离的
 同⽣共死

多⽤组合、少⽤继承
UML

静态模型

用例图（Use Case Diagram）：从用户角度描述系统功能。
类图（Class Diagram）：描述对象模型中类与类之间的关系。
组件图（Component Diagram）：描述系统中各个组件之间的依赖关系，还可以描述组件的源代码组织结构。
部署图（Deployment Diagram）：定义系统中软硬件的物理体系结构。
 
动态模型

时序图（Sequence Diagram）：显示对象之间的动态协作关系，强调对象之间消息 发送的时间顺序。
活动图（Activity Diagram）：显示活动的顺序控制流。
状态转换图（State Transition Diagram）：描述对象所有可能的状态，以及导致状 态转换的条件
 

类图（Class Diagram）
上层：类名
 中层：属性
 下层：行为（方法）
继承（泛化）实线白箭头
 关联 实线（小箭头）
 聚合 实线白菱形
 组合 实线黑菱形
 依赖 虚线（小箭头）
 实现（接口） 虚线白箭头
用例图（Use Case Diagram）

系统内部的功能
系统外部的参与者
以及它们之间的交互关系

用例的一般描述分为以下几个方面：
  简要说明
  主事件流和其他事件流
  前提条件
  事后条件
时序图 （Sequence Diagram ）
水平维度：显示对象之间发送消息的时间顺序；
 垂直维度：显示发送消息的时间顺序；

对象生命线（垂直的虚线）；
对象激活框（细长矩形）；
消息（带箭头的水平线 + 消息名）；

调用：实线段，实心箭头
返回：虚线段，枝状箭头
 
顶部方框表示类的对象或类，有3种写法

对象名和类名间用冒号隔开，如 c：Car
省略对象名称，：Car
 只保留对象名，c
 








 
 

模型分析








标准库
基础类lang
 工具类util
包
包名需全部小写
package myPath.myPackage;

com.example.mypackage
 









 包名的声明必须出现在第一行;


子包需要显式引用 ； 父包不包含子包

引用：
import java.util.Date; 
java.util.Date……

特定类
java.lang.Object 类
所有类的祖先
 仅有一个默认构造方法
public Object(){} // 方法体为空 

主要成员方法：

equals(Object obj) : 判断是否为同一对象
toString() : 返回对象的字符串表示，“类名@对象的十六进制哈希码”

包装类
基本类型->包装类
 boolean->Boolean
 int->Interger
 float->Float
 ……

所有的包装类都是final类型，不能创建子类
包装类是不可变类，不可强制转换

Boolean bln = new Boolean(true); 
Double d = new Double(“123.45D”);
Integer i = Integer.valueOf(“123”); 
Double d = Double.parseDouble(“123”);

Math
Math是final类
 有两个静态常量：E（自然对数）、PI（圆周率）
 Math类不能被实例化
Scanner
Scanner reader = new Scanner(System.in);
reader.nextInt();

Random
java.util.Random
Random random = new Random(); 
random.nextInt(100)+1;
random.nextInt();
Math.random ()

日期类
java.util.Date
Date date = new Date() ;
date.getTime();
返回1970年1月1日零点距今毫秒数

java.util.Calendar
Calendar cal = Calendar.getInstance(); 
cal.set(Calendar.YEAR, 2017); 

java.text.DateFormat
SimpleDateFormat dFormat = new SimpleDateFormat(“EEEE/MMMM/dd/yyyy”);
System.out.println(dFormat.format(date)); 

java.time
 ……略
Date d1 = dateFormat.parse(“2017-03-11”); 
Date d2 = dateFormat.parse(“2017-04-21”); 
long p = d2.getTime() - d1.getTime(); 

BigXXX类
如果整数的值比Long.MAX_VALUE还大，则需使用BigInteger
IO
大坑
字符串String
String str1 = new String("ABC"); 
String str2 = new String("ABC"); 
System.out.println(str1 == str2); // #false 地址不同
 
String str3 = "ABC"; 
String str4 = "ABC"; 
String str5 =  "AB" + "C";
System.out.println( str3 == str4 ); // #true
System.out.println(str3 == str5 ); // #true 
     
String a  = "ABC"; 
String b = "AB"; 
String c = b + "C";
System.out.println( a == c ); // #false 











int indexOf(int ch) ……
 int lastIndexOf(int ch) ……
 .charAt();
 .substring(11,15);
 String[] split(String regex, int limit);
 String concat(String str) //拼接
 String trim()
 String toLowerCase()
 String toUpperCase()
 String replace(char oldChar, char newChar)
 ……
类型转换
String->Numbers
String strInteger = new String(“10”);
 int num1 = Integer.parseInt(strInteger);  
String strFloat = new String(“3.14”); 
float num2 = Float.parseFloat(strFloat);

Numbers->String
int num1 = 10; 
float num2 = 3.14f;  
String str1 = String.valueOf(num1);
String str2 = String.valueOf(num2);

StringBuilder ???
图形编程










略……见另一篇
布局器：
Flow layout
 Box layout
 Border layout
 Grid layout
监听
public class Beeper implements ActionListener {
     ...
     // where initialization occurs:
     button.addActionListener(this);
    
      public void actionPerformed(ActionEvent e) {
         //Make a beep sound...
     }
 } 

MouseListener

2D graphics
paint() public void paint(Graphics g) { }
 repaint()
异常处理
Exception是程序运行时发生的异常事件，会中断程序的正常流程，比如IO时找不到文 件，访问数组越界等等。
 异常处理分离了一般代码和异常处理代码，更易阅读和维护。
 ① 检查性异常（checked exceptions）：程序正确，由于外在环境条件不足引发。Java编译器强制要求处理这类异常。
 ② 运行时异常（RuntimeException）：程序存在bug，需修改程序。
 ③ 运行时错误（Error）：极少见情况，非程序本身问题。
try-catch-finally
try { 
  code with exception 
} catch (ExceptionType name){
 … 
} finally {
 … 
}

标明异常 throws
用 throws 关键字指出可能出现的异常类型，自己不进行处理，由该函数的调用者处理。
 如果一个方法没有捕获一个检查性异常，那么该方法必须使用 throws 关键字来声明。
public void writeList() throws IOException { }

throw








集合框架
Collection
 集合用于存储、提取、操作和传递集成化的数据
接口：代表着集合的抽象数据类型。多级的接口构成了集合框架的标准调用接口。
 实现（类）：是集合接口的具体实现，可重复使用的数据结构。
 算法：用来执行一些有用的计算，这些算法的设计体现了多态。
 









接口
set
用于存放无重复的元素，类似数学意义上的集合
 不保证存放顺序
 Set set = new HashSet()
 Set中保存的是对象的引用
List
List是一个有序的Collection
 List为一个长度可变的数组，即动态数组 ArrayList、LinkedList
Queue
队列 first-in-first-out
Deque
双向队列
Map
按照无重复的键对象去检索值对象
 Map.Entry对象代表Map中的一对键与值
Map map = new HashMap();
map.put(“1”,”Mon.”); 
map.put(“1”,”Monday”); 
map.put(“one”,”Monday”); 
Set> set = map.entrySet(); 
for(Map.Entry entry : set)
  System.out.println(entry.getKey()+”:”+entry.getValue());

枚举类型
public enum Gender{FEMALE, MALE}
迭代器 Iterator 接口或ListIterator接口
import java.util.*;
 
public class Test{
 public static void main(String[] args) {
     List list=new ArrayList();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
     //第一种遍历方法使用foreach遍历List
     for (String str : list) {            //也可以改写for(int i=0;i ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}

Java 泛型
泛型方法
所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前
public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 输出数组元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型数组元素为:" );
        printArray( intArray  ); // 传递一个整型数组
 
        System.out.println( "\n双精度型数组元素为:" );
        printArray( doubleArray ); // 传递一个双精度型数组
 
        System.out.println( "\n字符型数组元素为:" );
        printArray( charArray ); // 传递一个字符型数组
    } 
}



继承
限制泛型类型

表示该通配符所代表的类型是T类型的子类。
 表示该通配符所代表的类型是T类型的父类。
public class MaximumTest
{
   // 比较三个值并返回最大值
   public static > T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

泛型类
public class Box {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box integerBox = new Box();
    Box stringBox = new Box();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

类型通配符
类型通配符一般是使用?代替具体的类型参数。例如 List 在逻辑上是List,List 等所有List<具体类型实参>的父类。
> 可比较大小
代码规范
import少用通配符：import java.util.*;
 一个源文件包含：

许可证或版权信息
package语句
import语句
类定义
 以上每个部分之间用一个空行隔开。
 类名 / 接口名 变量名 UpperCamelCase
 方法名 lowerCamelCase
 常量名 CONSTANT_CASE 全部字母大写，用下划线分隔单词

@author 标明开发该类模块的作者
 @version 标明该类模块的版本
 @see 参考转向，也就是相关主题
 @param 对方法中某参数的说明
 @return 对方法返回值的说明
 @exception 对方法可能抛出的异常进行说明
线程
进程 - 进行中的程序 拥有独立的内存空间
 线程 - “轻量级”的进程 线程存在于进程之中
 每个进程至少拥有一个线程，称为main thread， 主线程
 生命周期：新建 就绪 运行 死亡 堵塞
implements Runnable 
(new Thread(new HelloRunnable())).start();

extends Thread 
(new HelloThread()).start();

数据库
sql结构化查询语言










SQL语句语法，略
JDBC
执行SQL 语句的Java AP

连接数据源，比如数据库
向数据库发送所要执行的增删改查语句
从数据库接收语句执行的结果
 DriverManager 链接数据库
 Connection createStatement
 executeQuery for SQL select
 executeUpdate for SQL INSERT UPDATE DELETE
 ResultSet 结果集

ODBC
微软（MS）提出的一套数据库连接标准
 主要用于访问微软的数据
数据访问类 Data Access（DA）Class
好自为之，略……
设计模式
SOLID 原则








模型-视图-控制器 Model-View-Controller (MVC)
三层程序设计模型 Three-tier design model
表示层 （用户界面）
GUI class
 显示数据，接收操作
业务逻辑层 （问题域层）
PD class
 从用户界面接收请求，根据业务逻辑处理请求，从DA类获得数据/向DA类发 送数据，将处理结果送回表示层
数据访问层
DA class
 建立与数据库的连接，完成增删改查，关闭连接。

Java复习笔记——零碎知识点

OOP 类与对象

引用类型

for循环遍历

创建对象

封装 Encapsulation

继承 Heritage

子类初始化

final

上转型对象

抽象类

静态变量、方法 static

接口 interface

多态 Polymorphism

数组&实例

类的关系与UML图

类的关系

UML

类图（Class Diagram）

用例图（Use Case Diagram）

时序图 （Sequence Diagram ）

模型分析

标准库

包

特定类

java.lang.Object 类

包装类

Math

Scanner

Random

日期类

BigXXX类

IO

字符串String

类型转换

图形编程

布局器：

监听

2D graphics

异常处理

try-catch-finally

标明异常 throws

throw

集合框架

接口

set

List

Queue

Deque

Map

枚举类型

迭代器 Iterator 接口或ListIterator接口

Java 泛型

泛型方法

泛型类

类型通配符

代码规范

线程

数据库

sql结构化查询语言

JDBC

ODBC

数据访问类 Data Access（DA）Class

设计模式

SOLID 原则

模型-视图-控制器 Model-View-Controller (MVC)

三层程序设计模型 Three-tier design model

表示层 （用户界面）

业务逻辑层 （问题域层）

数据访问层

你可能感兴趣的:(Java复习笔记——零碎知识点)

时序图（Sequence Diagram ）

表示层（用户界面）

业务逻辑层（问题域层）