2019-04-08

子类能够继承父类中被声明为public和protected的成员变量和成员方法，但不能继承被声明为private的成员变量和成员方法
如果子类声明了一个与父类的成员变量同名的成员变量，则子类不能继承父类的成员变量，此时称子类的成员变量隐藏了父类的成员变量，此时如果想在子类中访问父类中被子类隐藏的成员方法或变量时，就可以使用super关键字
如果子类声明了一个与父类的成员方法同名的成员方法，则子类不能继承父类的成员方法，此时称子类的成员方法覆盖了父类的成员方法，此时如果想在子类中访问父类中被子类隐藏的成员方法或变量时，就可以使用super关键字
方法重载时，方法的返回值类型不能作为区分方法重载的标志，方法的重载指的是出现多个方法名相同，但参数个数或参数类型不同的方法
子类不能覆盖父类中声明为final或者static的方法
子类必须覆盖父类中声明为abstract的方法（没有实现的,在抽象类中创建的，必须要子类重写的方法称为abstract方法），或者子类也将该方法声明为abstract（声明了抽象方法的类也必须是抽象类）
抽象方法不能使用private 或static修饰
使用final修饰的类不能被继承，不能有子类，使用final修饰的方法不能被重写
内部类分为成员内部类、局部内部类、静态内部类、匿名内部类

成员内部类

public class Sample{
      public int id;
      class Inner{
      }
}

每个java类文件中只允许存在一个public公共类
只有创建了成员内部类的实例，才能使用成员内部类的变量和方法

Sample sample=new Sample();
Sample.Inner inner=sample.new Inner();

局部内部类

public void sell(){
      class Apple(){
      }
}

局部内部类和局部变量一样，都是在方法内定义的，其有效范围只在方法内部有效
局部内部类可以访问他的创建类中的所有成员变量和成员方法，包括私有方法

public class InnerClass {
    
    private String name;

    public InnerClass() {
        name = "苹果";
    }

    private void sell(int price) {
        class Apple {
            int innerPrice = 0;

            public Apple(int price) {
                this.innerPrice = price;
            }

            public void price() {
                System.out.print("现在开始销售：" + name);
                System.out.print("单价为：" + innerPrice);
            }
        }
        Apple apple = new Apple(price);
        apple.price();
    }

    public static void main(String[] args) {
        InnerClass inner = new InnerClass();
        inner.sell(100);
    }

}

现在开始销售：苹果单价为：100
Process finished with exit code 0

静态内部类可以在不创建外部类的时候直接

匿名内部类可以继承父类的方法，也可以重写父类的方法
匿名内部类可以访问外嵌类中的成员变量和方法，在匿名内部类中不能声明静态变量和静态方法

interface Apple{
      public void say();
}
public class Sample{
      public static void print(Apple apple）{
          apple.say();
}
public static void main(String [] args){
  Sample.print(new Apple(){
        public void say(){
    }
  });
}

接口是一个特殊的抽象类，在接口中也可以定义abstract方法，接口中所有的方法都没有方法体，
接口中有常量定义和方法定义两部分
接口可以被继承，接口可以实现多继承
接口中不能定义静态方法，抽象类中可以定义静态方法
接口中只能定义静态常量属性，不能定义普通属性，抽象类里可以定义静态常量属性，也可以定义普通属性
接口不能包含构造器，抽象类可以包含构造器，抽象类里的构造器是为了让其子类调用并完成初始化操作
接口不能包含初始化块，抽象类可以包含初始化块
一个类最多只能有一个直接父类，包括抽象类，但是一个类可以实现多个接口

public interface C extends interfaceA,interfaceB

java中的接口回调指的是，把实现某一接口的类所创建的对象的引用赋值给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口方法，实际上，当接口变量调用被类实现的接口方法时，就是通知相应的对象调用这个方法

public interface People{
    void say(String s);
}

class Teacher implements People{

    @Override
    public void say(String s) {
        System.out.println(s);
    }
}

class Student implements People{

    @Override
    public void say(String s) {
        System.out.println(s);
    }
}
class mainEducute{
    public static void main(String[] args){
            People people;              //声明接口变量
            people=new Teacher();      //接口变量中存放对象的引用
            people.say("我是老师"); //接口回调
            people=new Student();     //接口变量中存放对象的引用
            people.say("我是学生");//接口回调
    }
}

异常

public class People {
    public static int check(String strage) throws Exception{
        int age=Integer.parseInt(strage);
        if(age<0){
            throw new Exception("年龄不能为负数");
        }
        return age;
    }
    public static void main(String[] args){
        int myage= 0;
        try {
            myage = check("-101");
        } catch (Exception e) {
            System.out.println("数据逻辑错误");
            System.out.println("原因："+e.getMessage());
        }
        System.out.println(myage);
    }

}

数据逻辑错误
原因：年龄不能为负数
0

==表示两个对象的内存地址是否相等，equals表示两个字符串是否相等

Collection接口

containsAll()用来查看在该集合中是否存在指定集合中的所有对象，返回值为boolean型，如果存在返回true,不存在返回false
retainAll()方法仅保留该集合中同时包含在指定集合中的对象，其他的全部移除，返回值为boolean,如果存在符合条件的对象则返回true，否则返回false
removeAll()方法用来从该集合中移除同时包含在指定集合中的对象，与retainAll()方法正好相反，返回值为boolean型，如果存在符合移除条件的对象则返回true,否则返回false
addAll()方法用来将指定集合中的所有对象添加到该集合
contains(Object obj)用来查看在该集合中是否存在指定的对象，返回值为boolean型，如果存在则返回true,否则返回false

微信截图_20190412091722.png

List集合

subList(int fromIndex,int toIndex) 通过截取从起始索引位置fromIndex(包含)到终止索引位置toIndex（不包含）的对象，重新生成一个List集合返回
set（int index,Object obj）用来将集合中指定索引位置的对象修改为指定的对象
indexOf（Object obj）用来获取指定对象的索引位置，当存在多个时，返回第一个索引位置，不存在返回-1
lastIndexOf（Object obj）用来获得指定对象的索引位置，当存在多个时，返回最后一个的索引位置，当不存在时返回-1
add（int index,Object obj）用来向集合指定的索引位置添加对象，其他对象的索引位置相对后移一位，索引位置从0开始
addAll（int,Collection coll）用来向集合的指定索引位置添加指定集合中的所有对象

List为线性方式存储对象，ArrayList实现了List接口，采用数组结构保存对象，索引查询效率高，增删效率低

LinkedList采用链表结构保存对象，插入和删除效率高，查询效率低

LinkedList 定义的常用方法

addFirst（E obj）
addLast（E obj）
getFirst()
getLast()
removeFirst()
removeLast()

HashSet

hashSet实现的set集合不允许元素重复，根据对象的哈希码确定对象的位置，所以添加到由HashSet类实现的set集合中的对象，还需要重新实现hashCode()方法，从而保证插入集合中的对象能够合理的分布在集合中，以便快速定位集合中的对象

TreeSet

treeSet遍历对象是按照自然顺序递增排列，所以存入由treeSet类实现的Set集合的对象必须实现Comparable接口，也可能是按照指定比较器递增排列