终于把基础的大致学的差不多了 不够的 不深的以后再来补。今天照着视频复习一遍，也算是个小总结 纯粹记录 到时候自己回头过来看看 不是干货 都是湿货。

continue: 跳过本次循环语句，继续下一次循环。

continue的作用范围： 只能适用于循环语句。

一旦执行了continue语句，那么在循环体内continue之后的循环 语句跳过执行。

break: 用于结束一个循环语句或者是一个switch语句.

break作用范围： 只能用于循环语句或者是switch语句。

return 直接结束函数

可以看看这个 比较特殊 刚复习到 都忘了 break还可以配合标识

*outer:for(int j = 0 ; j<2; j++){ // j=0  j=1
inner:for(int i = 0 ; i<3 ; i++){ //i=0
    System.out.println("hello world");
    break outer; //结束当前所在的循环。 如果配合标识的使用，可以作用于外层的for循环。
            }//意思就是说 结束当前的外部outer

冒泡算法：

public static void sort(int[] buffer) {
        for (int i = 0; i < buffer.length-1; i++) {
            for (int j = i+1; j < buffer.length; j++) {
                if(buffer[j]<buffer[i]) {
                    int temp=buffer[j];
                    buffer[j]=buffer[i];
                    buffer[i]=temp;
                }
            }
        }
    }

复习到了算法 冒泡是最基础的排序算法 明天 整理下其他的常用算法吧 之前学的都忘了 重拾一下

函数的重载: 在一个类中出现了两个 或两个以上 的同名函数称作为函数的重载。

函数重载的作用： 一个函数名可以应对各种不同类型的参数。

函数重载的要求
1. 函数名一致。
2. 形参列表不一致（形参的个数不一致或者是形参对应 的类型不一致）
3. 与返回值类型无关。

函数重写：子父类出现了同名的函数称作为函数的重写。

函数重写必须要是在继承的关系才存在的。

函数重写的需求： 父类的功能无法满足子类的需求。

函数重写的要求
    1. 子父类的函数名与形参列表必须一致。
    2. 子类的权限修饰符必须 要大于或者等于父类的权限修饰符。
    3. 子类的返回值类型必须要小于或者等于父类的返回类型。
    4. 子类抛出的异常类型必须要小于或者等于父类抛出的异常类型。

记住： println 里面都是默认调用toString（）
封装 多态 继承 都是基础
继承的时候：父类私有的成员不能被继承。

简单看一个封装的栗子：

//封装的步骤：
    //1. 私有化要封装的属性。
    //2. 根据需求提供对应的get或者是set方法。
class Member{

    private String name;

    private String sex;



    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(String sex){
        if("男".equals(sex)||"女".equals(sex)){
            this.sex = sex;
        }
    }

    public String getSex(){

        return sex;
    }


}

instanceof 判断指定的对象是否属于某种类别。

instanceof 使用前提： 判断的对象与类别必须存在继承或者实现的关系。

instanceof 使用格式：
对象 instanceof 类别。

有多态才可能使用到instanceof关键字，

主要的应用场景： 数据类型强转之前的判断。

class Animal{}
class Dog extends Animal{}
public class One {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Animal animal=new Dog();
        if(animal instanceof Dog) {
            System.out.println("Yes");
        }

    }
}

输出 Yes

多线程栗子：

/*
线程：

多线程的存在的意义： 解决了一个进程允许多个任务可以同时执行。

多线程的创建方式：

    方式一:  继承Thread。
        1. 自定义一个类继承Thread.
        2. 重写Thread的run方法，把自定义线程的任务代码放在run方法上。
        3. 创建Thread类的子类对象，并且调用start方法开启线程。


    方式二： 实现Runnable接口。。
        1. 自定义一个类实现Runnable接口.
        2. 实现Runnable的run方法。把自定义线程的任务代码放在run方法上。
        3. 创建Runnable实现类的对象。
        4. 创建Thread的对象，然后把Runnable实现类的对象作为参数传递。
        5. 调用Thread对象的start方法开启线程。

java中的同步机制：

出现线程安全问题的根本原因：
    1. 存在两个或者两个以上的线程共享着资源。
    2. 操作资源的代码块必须有语句。


    1. 同步代码块

        同步代码块的格式：
            synchronized(锁对象){
                需要被同步的代码块...
            }
    同步代码块要注意的细节：
        1.锁对象可以是任意的对象。
        2. 锁对象必须 是多线程共享的资源。否则锁不住。
        3. 没有线程安全问题的时候不要使用锁，因为会导致效率降低。
        4. 调用sleep方法并不会释放锁对象，但是调用wait方法的线程就会释放锁对象。

    2. 同步函数
            修饰符 synchronized 返回值类型 函数名(形参列表..){

            }
    注意： 
        1. 同步函数的锁对象是不能任意的，非静态同步函数的锁对象是this对象，静态函数的锁对象是当前字节码对象。
        2. 同步函数的锁不能由你指定，是固定的。

 */
class MyThread2 implements Runnable{

    @Override
    public void run() {
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }

}




class MyThread extends Thread{

    @Override
    public void run() {
        //把自定义线程的任务代码代码写在这里。。
        for(int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
     }
}

public class Demo14  {

    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        thread1.start(); //开启了自定义的线程。线程一旦开启就会执行run方法中的代码块。


        MyThread2 thread2 = new MyThread2();
        //创建Thread的对象
        Thread t = new Thread(thread2);
        //调用Thread对象的start方法
        t.start();

    }
}

集合栗子：

/*

集合

单例集合
----------| Collection 单列集合的根接口
----------------| List 如果是实现了List接口集合类具备的特点： 有序，可重复。
-------------------| ArrayList   底层使用Object数组实现的。 特点： 查询速度快，增删慢。
-------------------| LinkedList  底层是使用了链表数据数据结构实现的。 特点： 查询慢，增删快。
-------------------| Vector(了解)   底层使用Object数组实现的， 实现与ArrayList是一样，只不过是线程安全的，操作效率低。

----------------| Set  如果是实现了Set接口集合类具备的特点： 无序，不可重复。
------------------| HashSet  底层使用的是哈希表实现的。  
------------------| TreeSet  底层使用二叉数实现。 

双列集合：
--------| Map  (只需要把Map接口的方法全部练习一次即可。)
-----------| HashMap  底层使用的是哈希表实现的。  
-----------| TreeMap   底层使用二叉数实现
-----------| HashTable（了解）

 */
class Book{

    String name;

    double price;

    public Book(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }

    @Override
    public int hashCode() {
        return this.name.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        Book b  = (Book)obj;
        return this.name.equals(b.name);
    }


    @Override
    public String toString() {
        return "[书名："+ this.name+" 价格："+this.price+"]";
    }
}

public class Demo15 {

    public static void main(String[] args) {
        //不允许重复的书名存在。
        HashSet<Book> books = new HashSet<Book>();
        books.add(new Book("深入javaweb",34));
        books.add(new Book("java神书",78));

        //修改书名
        Iterator<Book> it = books.iterator();
        while(it.hasNext()){
            Book b = it.next();
            if(b.name.equals("java神书")){
                b.name = "java编程思想";
            }
        }

        //为什么修改名字之后不能删除了呢?
        books.remove(new Book("java神书",78));

        System.out.println("集合的元素："+ books);




    }

}

/*
从键盘输入一个字母组成字符串，分别统计每个字母出现的次数(10分)
要求输出的效果按照字母的顺序输出  a(7)b(5)...
*/
public class Demo16 {

    public static void main(String[] args) {
        System.out.println("请输入一段字符串：");
        Scanner  scanner = new Scanner(System.in);
        String line = scanner.next();
        char[] arr = line.toCharArray();    //先把字符串转换成字符数组。
        TreeMap<Character, Integer> map = new TreeMap<Character, Integer>(); 
        for(char c : arr){
            if(map.containsKey(c)){ //map集合已经包含了该字符
                int count = map.get(c);
                map.put(c, count+1);
            }else{  //没有包含
                map.put(c, 1);
            }
        }
        System.out.println(map);


    }

}

输出：

三元运算符的格式：
布尔表达式?值1:值2 true 为值1 false为值2

构造代码块 ：是用来初始化类的 创建一个类 执行一次
静态构造代码块：类加载到内存的时候就执行 而且就执行一次

/*
构造代码块：给对象进行统一的初始化工作。

应用场景： 如何创建任意对象的时候都需要调用某个方法为该对象进行初始化时，这时候就可以使用构造代码块。

静态代码块:

静态代码块是静态代码块所属的类被加载到内存的时候执行的。


静态代码块的应用场景： 以后主要用于准备一个项目的初始化工作。 
    比如： 从配置配置文件中读取数据库用户名与密码。


 */

class Baby{

    int id;

    String name;

    //构造代码块的代码其实是在构造函数中执行的。 
    {

        cry();
    }

    static{
        System.out.println("静态代码块执行了...");
    }

    public Baby(int id, String name) {
        this.id = id;
        this.name = name;

    }

    public Baby(){

    }

    public void cry(){
        System.out.println("哭...");
    }

    @Override
    public String toString() {
        return " 编号："+this.id+" 姓名："+ this.name;
    } 
}




public class Demo9 {

    public static void main(String[] args) {
        Baby b1 = new Baby();
        Baby b2 = new Baby(110, "狗娃");
    }

}

内存分析：

/*
 多态： 父类的引用类型变量指向了子类的对象，或者是接口的引用类型变量指向接口实现类的对象。 

应用： 
    1. 多态应用于形参类型的时候，可以接收更多类型的参数，
        sort(List  list)
        sort(ArrayList list)
        sort(LinkedList list)

    2. 多态用于返回值类型的时候可以返回更多类型的参数。

迭代器的作用： 用于获取集合中的元素。     

 内部类： 

内部类的好处： 内部类可以直接访问外部类的成员。

 */

interface MyList{

    List subList(int fromIndex, int toIndex);
}






public class Demo12 {

    public static void main(String[] args) {    
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(10);
        list.add(19);
        list.add(12);
        list.add(6);

        Iterable<Integer> it = (Iterable<Integer>) list.iterator();
    }
}

匿名内部类：
/*
匿名对象：没有引用类型变量指向的对象就称作为匿名对象。

匿名内部类：没有类名的类就称作为匿名内部类。

匿名内部类使用前提： 必须存在继承或者实现关系。

因为匿名内部类没有类名，所以创建匿名内部类对象的时候就必须要借助与它父类的名字或者它父接口的名字来创建。 
但是匿名内部类只不过是没有类名，其他的一概成员都是具备的。


匿名内部类的应用场景： 主要是作为参数传递使用。

 */

interface Dao{

    public void add();
}

class Outer{

    public void print(){
        new Dao(){ //这里不是创建接口 的对象，是创建了Dao实现类的对象，但是这个类是一个匿名内部类而已，没有类名借用了父接口 的名字而已。
            //大括号中就写匿名内部类的成员。
            int  num =10;

            @Override
            public void add() {
                System.out.println("添加学生 ..");
            }
        }.add();

    }
}




public class Demo13 {

    public static void main(String[] args) {

        /*Outer outer = new Outer();
        outer.print();*/

        JButton button = new JButton("aa");
        button.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                System.out.println("aaa");

            }
        });


    }

}

/*
 匿名对象： 没有引用类型变量指向的对象就称作为匿名对象。

匿名对象的主要作用： 简化书写。

匿名对象主要用于两种应用场景：
    1. 如果一个对象的方法只会调用一次的时候，然后该对象就不再使用了，这时候就就可以使用匿名对象。
    2. 作为参数传递。
 */
    BufferedReader bufferedReader = new BufferedReader(new FileReader("F:\\a.txt"));