编程思想

面向过程：

分析出需要实现业务，细化步骤，完成每一步数据操作，最后依次执行每步过程。

面向对象：

面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

区别特点：

‘过程’=>‘对象’互作比较 相对性能 易维护 易复用 易扩展 低耦合性
面向过程 高 × × × ×
面向对象 低 √ √ √ √

概念

类：是一组相关的属性和行为的集合。是一个抽象的概念。
对象：对象就是真实世界中的实体，对象与实体是 一 一 对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。
对象特点：

  1.   - 对象具有属性和行为。
  2.   - 对象具有变化的状态。
  3.   - 对象具有唯一性。
  4.   - 对象都是某个类别的实例。
  5.   -  一切皆为对象，真实世界中的所有事物都可以视为对象。

类与对象的关系：类实际上是表示一个客观世界某类群体的一些基本特征抽象。对象就是表示一个个具体的东西。所以说类是对象的抽象，对象是类的具体。
方法：类中的行为，操作指定参数或数据进行系列步骤后，达到预计【属性更改|值计算|对象状态更改|。。。等等】的过程则称作方法。

java类

类名命名规则：

  1.   1. 类名应该以下划线（_）或字母开头，最好以字母开头。
  2.   1. 第一个字母最好大写，如果类名由多个单词组成，则每个单词的首字母最好都大写。
  3.   1. 类名不能为 Java 中的关键字，例如 boolean、this、int 等。
  4.   1. 类名不能包含任何嵌入的空格或点号以及除了下划线（_）和美元符号（$）字符之外的特殊字符。

语法中，中括号“[]”中的部分表示可以省略，竖线“|”表示“或关系”，例如 abstract|final，说明可以使用 abstract 或 final 关键字，但是两个关键字不能同时出现。

  1. [public][abstract|final]class<class_name>[extends<class_name>][implements<interface_name>] {
  2.     // 定义属性部分
  3.     [public|protected|private][static][final]<type><variable_name>
  4.     …
  5.     // 定义方法部分
  6.    [public|private|protected][static]<void|return_type><method_name>([paramList]) {
  7.         // 方法体
  8.     }
  9.     …
  10. }

格式中各关键词讲解：

  • public：表示“共有”的意思。如果使用 public 修饰，则可以被其他类和程序访问。每个 Java 程序的主类都必须是 public 类，作为公共工具供其他类和程序使用的类应定义为 public 类。
  • abstract：如果类被 abstract 修饰，则该类为抽象类，抽象类不能被实例化，但抽象类中可以有抽象方法（使用 abstract 修饰的方法）和具体方法（没有使用 abstract 修饰的方法）。继承该抽象类的所有子类都必须实现该抽象类中的所有抽象方法（除非子类也是抽象类）。
  • final：如果类被 final 修饰，则不允许被继承。
  • class：声明类的关键字。
  • class_name：类名称。
  • extends：继承类时使用关键词，后跟继承的类名称。只允许继承一个父类！
  • implements：实现接口时使用关键词，后跟实现接口类名称，可以同时实现多个！多个接口中间用“,”分隔。
  • property_type：参数类型。
  • property：成员变量名称。
  • function()：成员方法。
  • type/return_type：数据类型，数据类型可以是原始的数据类型，即常用的 8 种数据类型，也可以是一个引用数据类型，如一个类、接口和数组等。
  • void：无返回值

  • paramList ：表示参数列表，这些变量都要有自己的数据类型，可以是原始数据类型，也可以是复杂数据类型，一个方法主要依靠参数来传递消息。

    访问修饰符：

    • default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
    • private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
    • public : 对所有类可见。使用对象：类、接口、变量、方法
    • protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。 | 修饰符 | 当前类 | 同一包内 | 子孙类（同一包） | 子孙类（不同包） | 其他包 | | —- | —- | —- | —- | —- | —- | | public | √ | √ | √ | √ | √ | | protected | √ | √ | √ | √/×（说明） | × | | default | √ | √ | √ | × | × | | private | √ | × | × | × | × |

default - 默认访问修饰符-不使用任何关键词

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为 public。

  1. //变量修饰符示例
  2. String str = "cat";
  3. //方法修饰符示例
  4. String isProgramming(){
  5.     return "yes";
  6. }

private - 私有访问修饰符

所有被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

  1. public class Demo {
  3.     //变量修饰符示例
  4.     private String str = "cat";
  5.     //方法修饰符示例
  6.     private String isProgramming(){
  7.         return "yes";
  8.     }
  10. }

public - 公共访问修饰符

被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

  1. public class Demo {
  3.     //变量修饰符示例
  4.     public String str = "cat";
  5.     //方法修饰符示例
  6.     public String isProgramming(){
  7.         return "yes";
  8.     }
  10. }

protected - 受保护的访问修饰符

视两种情况而定：

  1.         1. **子类与基类在同一包中：**被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
  2.         1. **子类与基类不在同一包中：**那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
接口及接口的成员变量和成员方法不能声明为 protected。
子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

  1. public class Parent {
  3.     //变量修饰符示例
  4.     protected String str = "cat";
  5.     //方法修饰符示例
  6.     protected String isProgramming(){
  7.         return "yes";
  8.     }
  10. }

非访问修饰符：

  1.   - **static：**修饰符，用来修饰类方法和类变量。
  2.   - **final：**修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
  3.   - **abstract ： **修饰符，用来创建抽象类和抽象方法。
  4.   - **synchronized | volatile ：**修饰符，主要用于线程的编程。

static - 修饰符

static修饰符不能修饰局部变量和类！！！！

  1.      1. **静态变量：**static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
  2.      1. **静态方法：**static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
  1. public class Demo {
  3.     //变量修饰符示例
  4.     private static String str = "cat";
  5.     //方法修饰符示例
  6.     public static String isProgramming(){
  7.         return "yes";
  8.     }
  10. }
  11. //调用静态方法示例
  12.     Parent.isProgramming();

final- 修饰符

  1.      1. **final变量：**final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。final 修饰符通常和 static 修饰符一起使用来创建类常量。
  2.      1. **final方法：**父类中的 final 方法可以被子类继承，但是不能被子类重写。声明 final 方法的主要目的是防止该方法的内容被修改。
  3.      1. **final类：**final 类不能被继承，没有类能够继承 final 类的任何特性。
  1. public final class Demo {
  3.     //变量修饰符示例
  4.     private final static String str = "cat";
  5.     //方法修饰符示例
  6.     public final String isProgramming(){
  7.         return "yes";
  8.     }
  10. }

abstract- 修饰符

  1.      - **抽象类：**
  2.         - 1.** **抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
  3.         - 2. 一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
  4.         - 3. 抽象类可以包含抽象方法和非抽象方法。
  5.      - **抽象方法：**

抽象方法的声明以分号结尾，例如：public abstract sample();。

  1.         - 1. 抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。
  2.         - 2. 抽象方法不能被声明成 final 和 static。
  3.         - 3. 任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
  4.         - 4. 如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

synchronized- 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。不能用来修饰类或者变量！！

  1. public final class Demo {
  3.     public synchronized String isProgramming(){
  4.         return "yes";
  5.     }
  7. }

transient- 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

  1. public final class Demo {
  3.   public transient int limit = 55;   // 不会持久化
  4.   public int b; // 持久化
  6. }

volatile- 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

  1. public final class Demo {
  3.     //变量修饰符示例
  4.     private volatile String str = "cat";
  6. }