1.权限修饰符

java提供的四个权限修饰符

public公共的 private私有的 protected受保护的 default默认的（不写就是默认的）

这四个修饰符就是对类、方法、变量进行权限的修饰的

1.1private私有的

private不能修饰类，只能修饰方法和属性

1.只能在同一个类中去访问private修饰的方法和属性，

2.同一个包下的其他类不可以访问（即使有继承关系也不可以）

3.不同包下的其他类更让不能访问

总结：public修饰的属性和方法只能自己类使用

1.2default默认的

default可以修饰属性和方法，还可以修饰类

不写任何修饰符就是默认default

1.同一个类中可以访问属性、方法和类

2.同一个包下的其他类可以访问

3.在其他包下的类都不能访问

总结：只要是在同一个包下的类，都可以访问default修饰的属性、方法和类

        （出了这个包别人就用不了了）

1.3protectde受保护的

修饰属性和方法

1.同一个类中能访问

2.同一个包下的其他类也能访问

3.不同包下面继承该类的子类可以是用，其他类不行

总结：同一个包能用，不同包的继承该类的可以使用，其他不可以

1.4public公开的

修饰属性、方法和类

同一个类，同一个包下的不同类，不同包下的子类和其他类都可以使用

1.5总结

修饰符名称	当前类	同一个包的其他类	不同包的子、孙类	其他包的其他类
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
default	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以

总结：以后开发中public和private使用的居多。一般就用这两个

2.集合

2.1什么是集合

集合和数组是一样的都是用来存数据的，真实开发使用集合。

数组再存数据的时候：

    1.数组的容量是预先定义的
    2.数组的方法给咱们提供的太少了，大部分情况都是程序员自己写，麻烦
java封装了集合，封装好的集合类，咱们只需要去实例化对象然后调用封装好的方法即可

2.2集合的架构Collection

看API Collection

Interface Collection 这是java中所有集合的总接口

Collection下面有两个**重要的**子接口：List接口、Set接口

2.2.1 List接口

特征：存放数据时，有序的且可以重复的

类ArrayList 这个是List接口下的实现类，底层时数组，这个数组容量时可以调整大小的

类LinkedList 这个也是List接口下面的实现类，底层是一个双向队列

2.2.2 Set接口

特征：存放数据时，无序的且不可重复的

类HashSet Set接口下面的实现类，底层是hash表

类TerrSet Set接口下面的实现类，底层是树形结构

2.3Collection接口

学习Collection就是学习它下面的方法

Collection<E> 接口中的方法，他的子类都是可以使用的！！！继承关系
增：
    boolean add(E e);//添加数据到集合中，采用的是尾插法Demo1、Demo2
    //将集合添加到另一个集合    
    //而且必须数据类型一致才可以     list1.addAll(list2);
    boolean addAll(E e)；
删：
    boolean remove(object obj);//通过元素移除元素
    boolean removeAll(Collection c);//删除两个集合中的交集
    boolean clear();//清空集合
查：
    int size();//集合中元素的个数
    object[] toArray();//将集合转化为数组
    boolean contains(object obj);//判断元素是否在集合中，在T、不在F
    boolean containsAll();//是否是子集 ()是否是.前的子集
    boolean isEmpty();//是否为空

案例

list.add("朱志伟");//添加数据到集合中
list1.addAll(list2);//addAll将集合2中的数据存到集合1中，必须同类型
System.out.println(list1.remove("博儿"));//移除从左第一个出现的“博儿”
list2.removeAll(list1);//删除两个集合的交集
list1.clear();//清除list1中所有数据

2.4迭代器

迭代器是专门用来遍历数据的

之前的遍历：for循环、增强for循环（for each）

集合的遍历常用增强for循环

    Collection<String> list2 = new ArrayList<String>();
        list2.add("砖石");
        list2.add("利群");
        list2.add("南京");
        //第一步：获取迭代器对象
        Iterator<String> iterator = list2.iterator();
        //hasNext():如果有下一个元素返回true，有一个光标
        //光标初始位置在第一个元素前面。光标下面有元素返回true
//        System.out.println(iterator.hasNext());
//        for (int i = 0; i < list2.size(); i++) {
//            System.out.println(iterator.next());
//        }
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

package com.qfedu.test4diedaiqi;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
//for循环、增强foreach、迭代器
public class Demo1 {
    public static void main(String[] args) {
        Collection<String> list1 = new ArrayList<String>();
        list1.add("朱志伟");
        list1.add("朱航");
        list1.add("王梦哲");
        list1.add("刘子贤");
        list1.add("张桂园");
        list1.add("谷小天");
//        System.out.println(list1);
        //遍历1：for循环  list1[i]错误形式，所以不能直接用for循环遍历
        //变成数组在用for循环
//        Object[] objects = list1.toArray();
//        for (int i = 0; i < objects.length; i++) {
//            System.out.println(objects[i]);
//        }
        //遍历2：增强for循环  foreach
        /*
         * for(数据类型  临时变量：集合){
         * 
         * }
         * 将冒号后面的集合进行遍历，赋值给前面那个临时的变量
         */
//        for (String str:list1) {
//            System.out.println(str);
//        }
        //遍历3：迭代器
        Collection<String> list2 = new ArrayList<String>();
        list2.add("砖石");
        list2.add("利群");
        list2.add("南京");
        //第一步：获取迭代器对象
        Iterator<String> iterator = list2.iterator();
        //hasNext():如果有下一个元素返回true，有一个光标
        //光标初始位置在第一个元素前面。光标下面有元素返回true
//        System.out.println(iterator.hasNext());
//        for (int i = 0; i < list2.size(); i++) {
//            System.out.println(iterator.next());
//        }
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

2.5List接口【重点】

Collection接口在开发中不要，用List接口！！！为什么？

List是Collection的子接口，Collection接口的方法，List也是都可以用（子类比父类强）

子类不但重写了父类方法，还有自己的方法，所以开发用List

笔记中记Collection没有的，Collection有的都可以List都可以用
List：
    特征：有序的，可以重复的
        List独有的
    增：
        boolean add(int index,E e);//在指定位置添加指定的数据
        boolean addAll(int index,Collection c);//在指定位置添加一个集合到这个集合中，数据类型保持一致
    删：Collection中是通过元素来删除
        E remove(int index);//通过索引下标来删除
    改：
        E set(int index,E element);//通过索引找到元素，并修改元素
    查：
        E get(int index);//通过索引获得指定位置数据
        int indexOf(object o);//查找指定元素第一次出现的下标
        int lastIndexOf(object o);//查找指定元素最后一次出现的下标
        List<E> subList(int startIndex,int );//截取（要头不要尾）

案例

package com.qfedu.test5List;
import java.util.ArrayList;
import java.util.List;
public class Demo1 {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        list1.add("朱志伟");
        list1.add("朱航");
        list1.add(1, "哈哈");//指定位置添加数据
        System.out.println(list1);
        List<String> list2 = new ArrayList<String>();
        list2.add("谷小天");
        list2.add("张桂园");
        list2.addAll(2, list1);//在下边2出添加集合list1
        System.out.println(list2);
//        System.out.println(list2.remove("哈哈"));//通过元素删除
        System.out.println(list2.remove(3));//通过索引删除
        System.out.println(list2);//[谷小天, 张桂园, 朱志伟, 朱航]
        System.out.println(list2.set(2, "王梦哲"));//输出被修改的数据
        System.out.println(list2);//[谷小天, 张桂园, 王梦哲, 朱航]
        System.out.println(list2.get(1));//张桂园
        System.out.println(list2.get(2));//王梦哲
        //所以可以通过for循环遍历这个集合
        System.out.println(list2.indexOf("谷小天"));//0
        list2.add(3,"谷小天");
        System.out.println(list2);//[谷小天, 张桂园, 王梦哲, 谷小天, 朱航]
        System.out.println(list2.lastIndexOf("谷小天"));//3
        //截取
        List<String> list3 = list2.subList(1, 3);
        System.out.println(list3);//[张桂园, 王梦哲]
    }
}

2.6遍历集合中的数据

for、增强for、迭代器

package com.qfedu.test5List;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
//遍历
public class Demo2bianli {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        list1.add("朱志伟");
        list1.add("朱航");
        list1.add("王梦哲");
        list1.add("刘子贤");
        list1.add("张桂园");
        list1.add("谷小天");
        //迭代器       Collection使用Iterator
        //List使用ListIterator
        ListIterator<String> iterator = list1.listIterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("---------------------");
        //for循环
        for (int i = 0; i < list1.size(); i++) {
            System.out.println(list1.get(i));
        }
        System.out.println("---------------------");
        //foreach
        for (String string : list1) {
            System.out.println(string);
        }
    }
}

2.7集合中放对象【重点案例】

泛型是用来约束集合中存的数据类型的。

案例Demo2

package com.qfedu.test6jiheduixiang;
import java.util.ArrayList;
import java.util.List;
class Teacher{
    private String name;
    private int age;
    private double salary;//薪水
    public Teacher(String name, int age, double salary) {
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    @Override
    public String toString() {
        return "Teacher [name=" + name + ", age=" + age + ", salary=" + salary + "]";
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher("朱", 18, 9999);
        System.out.println(teacher);
        Teacher teacher1 = new Teacher("a", 20, 888);
        Teacher teacher2 = new Teacher("b", 30, 77);
        Teacher teacher3 = new Teacher("c", 40, 6);
        List<Teacher> list = new ArrayList<Teacher>();
        list.add(teacher);
        list.add(teacher1);
        list.add(teacher2);
        list.add(teacher3);
        System.out.println(list);
        //遍历 增强foreach  
        for (Teacher teacher4 : list) {
//            System.out.println(teacher4);//toString 数组输出
            System.out.println(teacher4.getName());
            System.out.println(teacher4.getAge());
            System.out.println(teacher4.getSalary());
            System.out.println("----");
        }
    }
}

zhuzhiwei

331权限修饰符、集合、Collection、List、迭代、增强for