java基础学习的一些笔记

//饿汉式，不存在线程安全问题


class Single{

private  static Single s= new Single();

private Single (){}

private static Single getInterface(){
 return s;
}
}


//懒汉式  ：延迟单例的加载例子，存在多线程安全问题，可以同步函数或同步代码，
  //若同步函数每次进来都要判断，浪费时间。所以选择同步代码。例子如下：


class Single{

private  static Single s= null;

private Single (){}
private static Single getInterface(){
if( s==null )
{synchronized(Single.class){//同步。
if( s==null ){
s=new Single();
}
}
}
return s;
}
}






类：对现实生活中事物的描述；（可以继承另外一个类同时实现多个接口）


对象：就是这类事物，实实在在存在的个体，


三种引用类型：数组类型，类类型，...


匿名对象(例:new Person())：对对象只调用一次时，可用匿名对象完成。也可作实际参数


构造函数作用：可以给对象进行初始化


构造代码块：构造代码块优先于构造函数执行


this: 代表本类的对象，


构造函数之间的调用的方式：只能用this语句 如this(参数)。(注:只能放在构造函数的第一行) ；


继承(子类继承了父类的东西，也可以调用，复写里面的成员)：提高了代码的重用性，让类与类之间产生了关系，有了这个关系才有多态的特性。子类对象可以调用父类的方法。


java；只能单继承，不支持多继承。支持多层继承(例，B继承A，C继承B)。
子父类中的函数：子类出现和父类中的函数一样时，当被子类对象调用时，执行的是子类函数的内容。


覆盖（重写）: 子类覆盖父类，必须保证子类权限大于等于父类的权限。子父类函数(名字，权限等)要一摸一样


重载：函数的参数列表不一样。


super语句 : 一定要放在子类构造函数的第一行（因为初始化动作先做，要放在第一行）
注意（子类的实例化过程）：子类的所有的构造函数默认都会访问父类中空参数的构造函数。
      因为子类每一个构造函数内的第一行都有一句隐式super();
      子类中至少有一个构造函数会访问父类中的构造函数。


final: （可以修饰类，函数，变量）修饰的类不可以被继承(避免类，成员，被子类复写)。
          可用final定义成常量。（全局变量形式：public static final）


抽象类（（abstract）即类中，没有实现其中方法的内容，即要描述的内容不一定，不同，此时可定义成抽象）： 不能用new创建对象，因为调用没意义。不能实例化。可以没有抽象方法。若其中的方法要被调用，必须由子类复写后创建子类对象调用。
           如果子类只复写了部分抽象方法，那么该子类还是一个抽象类。(要复写完所有的抽象方法才行
      （  abstract class fu{abstract void study();
abstract void study1();
} 
 class zi extend fu{
 void study(){};
 void study()1{};
     }
      若只覆盖了一个(即子类仍是抽象类)则要：
      abstract  class zi extend fu{
 void study(){};

     }
）
  ）


abstract ： 只能修饰类和方法，不能修饰变量，


模板方法设计模式：
/*
* 获取一段程序运行的时间，等于  结束时间-开始时间
* 获取时间：调用 Systerm.currentTimeMillis();返回毫秒值
*这种方式：  模板方法设计模式
* 模板方法设模式（思想：某个功能中有一部分功能需要子类去实现。但这部分功能不一定是抽象的）：  在定义功能时，功能的一部分是确定的，但是一部分是不确定的，而确定的部分在使用不确定的部分， 
*              那么这时就将不确定部分暴露出去，有该类的子类的去完成。 
*/
如：
abstract class GetTime
{
public final void getTime(){//final 修饰：防止被继承时被复写

long start = System.currentTimeMillis();
   run();
long end = System.currentTimeMillis();
System.out.println("所用时间:"+(end-start));
} 
public  abstract void run();//某段程序，不固定，所以定义成抽象的。

}


class  subcode extends GetTime
{
    public void run(){
for(int i=0; i<=100; i++ )
{System.out.print(i);}
 }

}


public class Main {
public static void main(String[] args) {
subcode sb = new subcode();
sb.getTime();
}
}


接口( interface，相当扩展功能 )：初期理解:可以认为是一个特殊的抽象类。
                     class 用于定义类，interface 定义接口。
格式特点：
1.接口常见定义: 常量，抽象方法
2.接口中的成员都有固定的修饰符
    常量：public static final 
    方法：public abstract 
    记住：接口中的成员都是public 的。接口不可以创建对象，因为有抽象方法。
  
   接口可以多实现，多继承。


           实现接口（implements + 接口名称）


多态: 可以理解为事物存在的多钟体现形态。






集合框架：
     Set集合：
1.HashSet；数据结构是哈希表，线程是非同步的，
保证元素唯一性原理。判断元素的hashCode值是否相同
如果相同，还会继续判断元素的equals方法，是否为true

2.TreeSet：可以对Set集合中的元素进行排序，
底层数据结构是二叉树
保证元素唯一性；
compareTo方法中：
ruturn 0 表示元素相等;ruturn 1 表示前元素大；ruturn -1 表示前元素小

TreeSet的第一种排序方式是，让元素自身具有比较性。
需要实现Conparable接口，覆盖compareTo方法
也称元素的自然顺序，或是默认顺序


记得一定要覆盖compareTo方法。（返回的是int类型的）


TreeSet的第二种排序方式是：
  当元素自身不具备比较性时，或者具备的比较性‘不是所需要的，
  让容器自身具有比较性。
  在集合初始化时，
  方法：
        定义一个类(如MyCompartor)，实现Compartor接口，覆盖compare(obj o1,obj 02)方法(即为比较器)
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数( new TreeSet( new MyCompartor() ) )，

当两种排序都存在时，以比较器为主


        记住：排序时，当主要条件相同时，一定要判断下一次的条件。