java

变量

数据类型

基本数据类型 ： byte(1),short(2),int(4),long(8),char(2),double,float,boolean

引用数据类型   :  数组(array),类(class),接口(interface)

常量 : 只能初始化一次

final int num = 20;

final修饰类，不能被继承（String,Math）

final修饰方法，不能被子类重写

final修饰属性，常量

数组

for,while,do{}while()至少执行一次

int arr[] = {1,2,3}

int arr[] = new int[]{1,2,3};

int arr[] = new int[3];

String arr[] = new String[3];

Student arr[] = new Student[3];

冒泡排序

//外循环---一共比多少轮
        for(int i=1;i<a.length;i++) {
            //每一轮都从第一个开始
            for(int j=0;j<a.length-1;j++) {
                if(a[j]<a[j+1]) {
                    int x;
                    x=a[j];
                    a[j]=a[j+1];
                    a[j+1]=x;
                }
                
            }
        }
        for(int b:a) {
            System.out.println(b);
        }

选择排序

//2.选择排序
        for(int i=0;i<a.length-1;i++) {
            for(int j=i+1;j<a.length;j++) {
                if(a[i]>a[j]) {
                    int x;
                    x=a[i];
                    a[i]=a[j];
                    a[j]=x;
                }
            }
        }
        for(int b:a) {
            System.out.println(b);
        }

二维数组：

int arr = {{1,2,3},{4},{5,6}};

方法

(public protected private) static 返回值 方法名(参数列表){

}

重写 (override)： 子类重写父类方法，同名同参同返回值

1.发生在父类与子类之间
2.方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同

重载 (Overload)： 同一类中，同名不同参的方法

1.重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序)
2.重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标

面向对象

继承（extends）

一个类可以从一个现有类中派生出来，派生出的类称为子类，子类拥有父类所有属性和方法，除了私有   成员和构造器，子类还可以拓展自己独有的属性和方法，是代码重用的一种手段，也是实现开闭原则的基础

重写：子类重写父类方法，同名同参同返回值

封装（Wrapper ）

采用不同的修饰符（public protected private 默认的）控制代码的可见范围

多态

对同一消息做出不同响应，在java中体现为重写（override,运行时多态）和重载

它是一种编程模式，①要有泛化；②要有上溯造型；③要有方法重写  

解耦合 

抽象（abstract）

将事物的主要特性抽象成概念模型，在java中接口，抽象类都是抽象的体现

抽象类 ： 不能实例化（有构造器）

public abstract class Demo{
    public void test(){}
    public abstract void test1(int num);
}

抽象类和接口的异同：

接口和抽象类都不能实例化

接口没有构造器

接口中只有常量和抽象方法

类是单继承，接口是多实现

static:静态

主要修饰方法和属性

可以直接通过类名.属性名或方法名来调用

静态的属性和方法保存在方法区，他们是共享数据

单例模式（工厂） : 节省资源

// 饿汉模式
public class Singleton{
    private static Singleton singleton = new Singleton()；
    private Singleton(){}
    public static Singleton getInstance(){
        return singleton;
    }
}
// 懒加载
public class Singleton{
    private static Singleton singleton；
    private Singleton(){}
    public static Singleton getInstance(){
        if(singleton == null){
            singleton =  new Singleton()；
        }   
        return singleton;
    }
}

String，StringBuffer，StringBuilder区别

String :代表一组不可变的字符串，字符串常量对他的所有修改都是在创建新的字符串，不是在原有的基础上修改
StringBuffer :代表一组可变的字符串，对他的所有修改都是在原有基础上进行的
StringBuilder :数据不同步（线程不安全）效率更高

集合

      数组：他能保存一组元素，数据类型必须一致，定长
      
      集合：它也能保存一组元素（只能是引用数据类型），任意数据类型都可以保存，自动扩容
      
      Collection接口
      
            List    子接口--有序（元素存入的顺序和元素在集合当中真实的顺序一样）有重复
      
                ArrayList   --它是基于数组实现的，内部其实是创建了一个长度为10的Object类型数组
                                 当元素个数超过10，ArrayList会自动扩容到原来的1.5倍
                                 数组是一种静态线性表，逻辑是连续的，物理也是连续的
                                 随机查询速度较快
      
                LinkedList  --他是基于链表实现的，链表是动态线性表，逻辑是连续的，物理是不连续的
                            --随机查询速度较慢，他的插入删除速度比较快
                Vector他是基于数组实现的，它与ArrayList的区别就在于Vector是书库同步的（线程安全）
      
            Set     子接口--无序（元素存入的顺序和元素在集合当中真是的顺序不一样）无重复
                HashSet
                ---TreeSet：内部有排序。局限性强
      常用方法  add()  size()  contains()
                    
      
     
      Map:以键值对的形式保存元素(无序的)
      键不能重复  否则会被覆盖
                HashMap     --数据不用补（线程不安全）      null也可以作为key或者value
                HashTable   --数据同步（线程安全）            null不可以作为key或者value
                ---TreeMap：内部有排序。局限性强
      
                常用方法 put containskey

//Map遍历
Map<String,String> map = new HashMap();
for(Entry<String,String> entry : map.entrySet()){
    System.out.println(entry.getKey()+","+entry.getValue());

}

文件相关

public class Test{
    public void test(){
        // 创建对象
        File file1 = new File("D:\\abc.txt");
        // 判断对象所代表的文件路径是否存在
        if(!file1.exsits){
            // 创建文件
            file1.creatNewFile();
        }
        
        // 创建对象
        File file2 = new File("D:\\abc\\xyz");
        if(!file2.exsits){
            // 创建文件夹
            file2.mkdirs();
        }
    }
}