Java编程思想学习

Java编程思想汇总

1：对象导论

1.1：类和对象

类是具有相同特性和行为的对象集合，也就是相当于我们创建的一种抽象的数据类型。每个操作者都可以创建自己的对象操作该集合。
内存中的运行方式：类和基本数据类型基本一致。
**对象：**是某个类的实例，每个对象在内存中地址都是唯一的！

1.2：访问权限

Java中有四种访问权限，public > protected > default(包访问权限) > private。
下面用表格表示四种权限

1、public： 所修饰的类、变量、方法，在内外包均具有访问权限；
2、protected： 这种权限是为继承而设计的，protected所修饰的成员，对所有子类是可访问的，但只对同包的类是可访问的，对外包的非子类是不可以访问；
3、包访问权限（default）： 只对同包的类具有访问的权限，外包的所有类都不能访问；
4、private： 私有的权限，只对本类的方法可以使用；

1：访问权限使用

访问权限包括类的使用，类内部成员的使用、接口的使用。

1.1：类的权限

外部类（外部接口） 是相对于内部类（也称为嵌套类）、内部接口而言的。外部类的访问控制只能是这两种：public 、default 。

1.2：类内部成员权限

类里面的成员分为三类 ： 全局变量、成员方法、成员内部类（内部接口）、局部变量。
全局变量、成员方法：权限参照表格
内部类：只能用private修饰，一个类中只能有一个是public的
抽象方法：不能使用private修饰，抽象方法不能是私有的，否则，子类就无法继承实现抽象方法
局部成员：是没有访问权限控制的，因为局部成员只在其所在的作用域内起作用

1.3：接口成员的访问权限

接口由于其的特殊性，所有成员的访问权限都规定得死死的，下面是接口成员的访问权限：
变量： public static final
抽象方法： public abstract
静态方法： public static，JDK1.8后才支持
内部类、内部接口 ： public static

1.3：java的面向对象设计原则

主要遵循6大原则
浅谈设计模式和设计原则

2：多态

多态性是对象多种表现形式的体现。

2.1：优点

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

2.2：实现方式

多态的实现有3大必要条件：
继承；重写；父类引用指向子类对象

1：继承

继承就是多态的一种实现方式。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，对父类的行为进行重写实现自己的功能
重写：重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

1.1：继承特性

继承的特性 子类拥有父类非 private 的属性、方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 B 类继承 A 类，C 类继承 B 类，所以按照关系就是 B 类是 C 类的父类，A 类是 B 类的父类。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

1.2：继承关键字

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的，一般形式如下：

class 父类 {
}
 
class 子类 extends 父类 {
}

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。

2：接口

接口是一个抽象类型，是抽象方法的集合，接口用interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法，进行接口的拓展，接口实现通过implements关键字。利用接口可以更好的进行扩展，进行解耦。

2.1：接口特性

接口中每一个方法必须都是抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

接口实例定义

public interface demo{
   public void eat();
   public void travel();
}

接口实现使用implements关键字实现接口

public class testimplements demo{
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }

2.2：接口和工厂模式

用于生成遵循某个接口对象的方式就是工厂方法设计模式，通过接口中的方法返回值类型来提供另一接口的的对象，用于具体调用时提供工厂方法去调用接口。提升了框架结构性。

3：抽象类和抽象方法

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

使用：抽象类用abstract 来定义。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用

3.1：实例DEMO

抽象类和抽象方法

public abstract class Employee                     //抽象类
{
   private String name;
   private String address;
   private int number;
   public abstract double computePay();                     //抽象方法，没有方法体，留给实现类去实现
}

抽象类的实现由继承去实现，并且抽象方法必须全部被子类实现

3.2：抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，没有实体方法的抽象类合接口区别不大
   但是接口中的方法不行。可以简单理解接口比抽象类更抽象，更宽泛。
2. 抽象类中的成员变量可以是各种类型的
   接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)
   而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
   抽象类和接口的选择
   抽象类：对实际物体的抽象，比如猫狗和动物
   接口：对物体共有特征的定义，定义一些共有的功能，用于后续实现

4：重写和重载

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

(1)重载：是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
(2)重写：是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。

3：内部类

将一个类定义在另一个给类里面或者方法里面，这样的类就被称为内部类。
内部类可以分为四种:成员内部类、局部内部类、匿名内部类、静态内部类

3.1：内部类优点

1、完善了Java多继承机制，由于每一个内部类都可以独立的继承接口或类，所以无论外部类是否继承或实现了某个类或接口，对于内部类没有影响。
2、方便写事件驱动程序。

3.2：成员内部类

成员内部类不能含有static的变量和方法

public  class C{
    class D{   //内部类D
    }
}

成员内部类可以无条件访问外部类的属性和方法，但是外部类想要访问内部类属性或方法时，必须要创建一个内部类对象，然后通过该对象访问内部类的属性或方法。

3.3：局部内部类

局部内部类存在于方法中。
他和成员内部类的区别在于局部内部类的访问权限仅限于方法或作用域内。
局部内部类就像局部变量一样，前面不能访问修饰符以及static修饰符。

class A{
    public void say(){
        class B{
        }
    }
}

3.4：匿名内部类

就是没有名字的类。匿名内部类和局部内部类只能访问外部类的final变量。
使用位置：内部类可以继承或实现一个外部类或者接口，最常见的就是方法的形参列表上。

public static void driveCar(Car car){         
        car.drive();
    }
    
public static void main(String[] args) {
        driveCar(new Car(){      //new car（）部分就是一个匿名内部类
            @Override
            public void drive() {
                System.out.println("驾驶着BMW汽车");
            }
        });
    }

3.5：静态内部类

静态内部类和成员内部类相比多了一个static修饰符。它与类的静态成员变量一般，是不依赖于外部类的。同时静态内部类也有它的特殊性。因为外部类加载时只会加载静态域，所以静态内部类不能使用外部类的非静态变量与方法。

class U {
    static class I {        
    }
}

4：容器

Java 容器分为 Collection 和 Map 两大类，其下又有很多子类

包含三大体系：collection体系，map体系，工具类体系
数组：申请内存空间要连续，所以插入删除慢（需要移动后续的所有元素），随机访问快（a[i]_address = base_address + i * data_type_size）。base_address 首元素的内存地址
链表：申请内存空间不连续，利用率高，插入删除快（只改变相邻的指针即可），随机访问慢（全部遍历）

4.1：list

1:ArrayList

特性：随机访问快（内部是数组，根据数组下标，读取复杂度1），而插入移除比较慢。

//默认创建大小为10的数组，超过才进行扩容
 private static final int DEFAULT_CAPACITY = 10;
    public void add(int index, E element) {  //add插入操作时
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
               size - index);  //进行扩容，插入i位置，会将i位置后所有的都复制移动
        elementData[index] = element;  //给数组赋值
        size++;
    }

2：LinkedList和Vector

是基于链表实现的。相比于ArrayList其特点是查询慢（空间不连续），增删快。
Vector ：Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。所以现在已经不太常用了

4.2：Map

Map不是collection的子接口或者实现类。Map是一个接口，用于存放k-v键值对数据

1：HashMap

HashMap线程不安全，是非synchronized

2：Hashtable

Hashtable是synchronized，这意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好，使用线程安全的map时应该使用ConcurrentHashMap（分段锁效率更高）

4.3：set

Set中不允许数据重复
HashSet查询速度比较快，但是存储的元素是随机的并没有排序。
TreeSet是将元素存储红-黑树结构中，数据有序。

4.4：容器正确删除数据

容器中数据删除时不能放在for循环中进行，正确方式应该使用iterator迭代器

 Iterator<String> iterator=userList.iterator();
        while (iterator.hasNext()){
            iterator.next();
            iterator.remove();
        }

4.5：Collections和Arrays

为了方便对Array对象、Collection对象进行操作，Java中提供了Arrays类和Collections类对其进行操作。

Arrsys:是数组的工具类，提供了对数组操作的工具方法。

Collections:是集合对象的工具类，提供了操作集合的工具方法。

其中Arrays和Collections中所有的方法都为静态的，不需要创建对象，直接使用类名调用即可。

比如排序：Collections.sort()

5：