java知识盲点记录与补充

2020.7.8

栈内存和堆内存

栈内存：存储局部变量。使用完立消失。
堆内存：存储实体，对象。用完不会立消失，会在垃回收器空闲时回收。例子：

int [] a = new int[3];
		//a存储于栈内存，new出来的对象存储于堆内存
		//栈：局部变量使用完立消失，堆：实体，对象。用完不会立消失，会在垃回收器空闲时回收。
		System.out.println(a);
		//先找地址，再找到索引，进而找到索引对应的值
		System.out.println(a[2]);

public class TestJava{
	public static void main(String[] args){
		
		int i[] ={10,20,30};
		//静态初始化，i代表的是地址
		System.out.println("修改前的值"+i[1]);
		//传地址进去就是实参
		exchange(i);
		System.out.println("修改后的值"+i[1]);
		//动态初始化
		//new 为数组申请内存空间I@139a55
	}
	public static void exchange(int[] i){
		i[1] = 80;
	}	
}

2020.7.9

super和this关键字的理解

this代表本类对象的引用（地址），super表示父类存储空间的标识。
this可以用来访问子类的成员变量、构造方法和子类成员方法，super可以用来访问父类的成员变量、构造方法和父类成员方法。

<p><tr>
     <td>关键字</td>
     <td>访问成员变量</td>
     <td>访问构造方法</td>
     <td>访问成员方法</td>
</tr>
<tr>
    <td>this</td>
    <td>this.成员变量</td>
    <td>this(...)</td>
    <td>this.成员方法</td>
</tr></p>
<p><tr>
     <td>super</td>
    <td>super.成员变量</td>
    <td>super(...)</td>
    <td>super.成员方法</td>
</tr></p>

继承中构造方法的访问特点：
子类创建对象的时候，子类构造方法第一句默认是super(),也就是调用父类的无参构造方法。

package extend;
public class Fu {
	public Fu(){
		System.out.println("父类中的无参构造方法");
	}
	public Fu(int a){
		System.out.println("父类中的带参构造方法");
	}
}

package extend;
public class Zi extends Fu{
	public Zi(){
		//不写的话默认也是默认使用super
		super(20);
		System.out.println("子类中的无参构造方法");
	}
	public Zi(int a){
		super(20);
		System.out.println("子类中的带参构造方法");
	}
}

package extend;

public class TestExtends {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Zi z1 = new Zi();
	}
}

Override注解帮助检查方法重写声明的正确性

	@Override
	//Override注解帮助检查方法重写声明的正确性
	public void show(){
		//调用父类的show();
		super.show();
		System.out.println("子类中show()方法");
	}
}

父类私有方法，子类无法重写。
子类方法的访问权限要不能比父类更低。(public > 默认 >private )

包

如果有相同名的类，使用包区分

带包编译命令如下：（注意.）

javac -d . test.java

java源文件中加上包声明：

package com.lijugang.www;
public class test{
	public static void main(String[] args){
		System.out.println("hello world");
	}
}

类

类是对象的抽象，对象是类的实体。

类有属性和行为，属性就是成员变量，行为就是成员方法。

成员变量存储于堆内存，系统会分配默认的初始值，而局部变量不会自动分配初始值，需要显示的初始化。

标准类的制作

1.成员变量（private修饰） 2.构造方法（无参和有参）3.set和get方法

封装

给成员变量加上private关键字，可以保护成员变量不被其他类直接使用，而在本类中可以直接使用。

如果要访问private修饰的成员变量，则需要通过get和set方法获取和设置值。

封装的好处？1.提高代码的安全性（private修饰成员变量，提供get和set方法），可以在方法中提供数据安全的校验。2.代码复用

2020.7.11

字符串

String s = “abc”,其实维护在常量池中，跟new出来的有区别

字符串比较内容通过equal()方法，比较值或者引用使用==。

StringBulider

是为了解决字符串拼接浪费时间和空间的问题。

append()返回对象本身。

    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

字符串翻转方法，直接匿名返回，链式编程（由于返回对象本身）。

    public static String reverseString(String s){
        return new StringBuilder(s).reverse().toString();
    }
}

ArrayList

ArrayList存储学生对象，通过键盘录入

//students是个引用类型，方法里面改变，方法外面也会改变
//返回值：void
//参数：ArrayList

package com.lijugang.collection;
import java.util.ArrayList;
import java.util.Scanner;

public class StudentInput {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();
        while(true){
            addStudent(students);
        }
    }
    //students是个引用类型，方法里面改变，方法外面也会改变
    //返回值：void
    //参数：ArrayList<Student>
    public static void addStudent(ArrayList<Student> students){
        Scanner sc = new Scanner(System.in);
        String name = sc.nextLine();
        int age = sc.nextInt();
        Student s = new Student(name,age);
        students.add(s);
        System.out.println(s.getAge()+s.getName());
    }
}

final

修饰基本类型，基本类型就是常量，值不能改变。修饰引用的话，地址值不能改变。

static

1.被所用对象共享的成员变量使用static修饰，使用类名.变量名访问。

2.静态方法中只能访问静态成员变量和成员方法。

3.非静态的方法可以访问静态和非静态。

2020.7.12

多态

成员变量：编译看左边，执行看 左边。

成员方法：编译看左边，执行看右边。（由于重写）

多态的好处是在定义方法的时候，可以以父类对象作为参数，在使用的时候以子类型参与操作。弊端是不能使用子类的独有功能（可以使用向下转型解决这个问题，见下文）。

package duotai;

public class Animal {
    public int weight = 10;
    public int age = 20;
    public void eat(){
        System.out.println("动物吃东西");
    }
}

package duotai;

public class Dog extends Animal {
    public void eat(){
        System.out.println("狗吃骨头");
    }
    //狗的独有方法
    public void lookDoor(){
        System.out.println("狗看门");
    }
}

package duotai;

public class AnimalOperator {
    public void useAnimal (Animal a){
        a.eat();
    }
}

package duotai;

public class Cat extends Animal {
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫在捉迷藏");
    }
}

package duotai;

public class AnimalDemo {
    public static void main(String[] args) {
        AnimalOperator ao = new AnimalOperator();
        Dog d = new Dog();
        ao.useAnimal(d);
        ao.lookDoor(d);//报错，lookDoor为独有方法
    }
}

向下转型可以解决子类独有方法的访问问题，父类对象强转为子类对象。

package duotai02;

public class AnimalDemo {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();
        a.eat();

//        Cat c = new Cat();
//        c.playGame();

        //向下转型,父类对象强转为子类对象
        Cat c = (Cat)a;
        c.playGame();
    }
}

类型转换失败

package duotai02;

public class AnimalDemo {
    public static void main(String[] args) {
        //向上转型
        Animal a = new Cat();//第一次分配内存空间，内存是猫
        a.eat();
        //向下转型
        Cat c = (Cat)a;
        c.playGame();
        
        a = new Dog();//重新分配内存空间,内存是狗
        Cat cc = (Cat)a;//狗不能转为猫
        cc.eat();
    }
}

Exception in thread "main" java.lang.ClassCastException: duotai02.Dog cannot be cast to duotai02.Cat at duotai02.AnimalDemo.main(AnimalDemo.java:15)

多态的形式：具体类的多态，抽象类的多态，接口类的多态

接口

1.接口中的成员变量默认是final和static修饰。

2.接口没有构造方法。

3.接口中不能有不能有非抽象方法，不能用public修饰，默认带abstract修饰。

public class Cat extends Object implements Jumpping{
    //默认继承的是Object的构造方法
    public Cat() {
    }

    public void jump(){
        System.out.println("猫可以跳高了");
    }
}

2020.8.1

引用类型的变量使用之前一般先判断是否为null,只要是对象，在使用之前就必须进行不为null的判断

Integer a = 100;
Integer a = null;//NullPointerException
if(a != null){
    a += 300;
}

2020.8.2

runtime exception指程序运行期间出现的问题，编译时不检查，不需要捕获。例如数组越界。

可查异常，编译异常必须进行异常处理。

使用throws抛出异常，但没有做处理，不能向后执行。

throw用在方法体内部，使用形式为throw new 对象，throws是跟在类后面。

2020.8.9

Collection

常用方法

boolean add(E e),boolean remove(Object o),void clear,boolean contains(Object o),boolean isEmpty(),int size(),

遍历

Iterator iterator() ,有next()和hasNext()方法，这里会有并发修改异常，在listIterator()中解决
迭代器是依赖于集合而存在的，在判断成功之后，集合当中增加了新的元素，而迭代器却不知道，所以就报错了，这个就叫并发修改异常。

List

常用方法

void add(int index,E element), E remove(int index),E set(int index,E e),E get(int index)

遍历

listiterator() ----- 独有 void add(E e) 这个迭代器可以向列表中直接插入元素

注意返回值和 传的参数不一样，list的返回值类型为元素，Collection返回值类型为boolean。

ArrayList和Linkedlist

查找与插入、删除的区别。

Set

HashSet

要保证元素的唯一性，就必须重写hashcode()和equals()

hash table在jdk8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组。在jdk8以后，在长度较长的时候做了优化。

首先对对象的哈希值模16（hashset默认初始容量为16），余数相同，则在这个位置上链式存储。按余数存储，比较哈希值和对象里面的内容。

LinkedHashSet

底层由链表和哈希表实现，保证不重复，有序。

public class LinkedHashSetTest {
    public static void main(String[] args) {
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("asdaaaa");
        linkedHashSet.add("sabbb");
        linkedHashSet.add("vcccc");
        linkedHashSet.add("vcccc");

        for(String s:linkedHashSet){
            System.out.println(s);
        }
    }
}

TreeSet

自然排序

无参构造方法使用自然排序对元素进行排序。就是让元素所属类实现Comparable接口，重写CompareTo()方法

重写方法时，一定要注意排序规则要按照要求的主要条件和次要条件来写

package collection0806;

import java.util.Objects;

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    //自然排序方法
    public int compareTo(Student s) {
        //返回0重复不排序
        //正数升序
        //this相当于s1，s相当于s2
        int num = this.age - s.age;
        int num2 = num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}

    public static void main(String[] args) {

        TreeSet<Student> students = new TreeSet<>();
        Student s1 = new Student("赵六",20);
        Student s2 = new Student("张三",30);
        Student s3 = new Student("王五",10);
        Student s4 = new Student("测试",10);

        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);

        for (Student s:students){
            System.out.println(s.getAge()+s.getName());
        }
    }

比较器排序

带参构造方法:（接口的匿名类实现）

package treesettest;

public class Student {
    private String name;
    private  int Chinese;
    private int math;

    public Student() {
    }

    public Student(String name, int chinese, int math) {
        this.name = name;
        Chinese = chinese;
        this.math = math;
    }

    public String getName() {
        return name;
    }

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

    public int getChinese() {
        return Chinese;
    }

    public void setChinese(int chinese) {
        Chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }

    public int getSum(){
        return this.getChinese()+this.getMath();
    }
}

package treesettest;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeTestDemo {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //int num = (s2.getChinese() + s2.getMath()) - (s1.getChinese() + s1.getMath());
                int num = s2.getSum() - s1.getSum();//主要条件
                int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;//次要条件
                int num3 = num2 == 0 ? s1.getName().compareTo(s2.getName()) : num2;
                return num3;
            }
        });

        Student s1 = new Student("李好好", 80, 91);
        Student s2 = new Student("李举刚", 90, 99);
        Student s3 = new Student("王嘉婷", 100, 100);
        Student s4 = new Student("张曼玉", 79, 92);//无次要条件，无法添加，重复元素
        Student s5 = new Student("测试", 79, 92);//


        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        for (Student s : ts) {
            System.out.println(s.getName() + s.getSum());
        }
    }
}

内部类

成员内部类

和成员变量位置相同

public class OuterTest {
    private  int num =10;
    private class Inner{
        public void show(){
            System.out.println(num);
        }
    }
    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

public class InnerDemo {
    public static void main(String[] args) {

        OuterTest ot = new OuterTest();
        ot.method();//间接调用了内部类
    }
}

局部内部类

定义在类的方法里面

匿名内部类

new 类名或者接口名(){
    //重写方法
}

new Inner(){
    public voif show(){
        
    }
}

本质：继承该类或者实现了该接口的子类匿名对象

2020.8.16

泛型类

定义格式：public class Generic{}

package fanxing0816;

public class Generic<T> {
    private T t;

    public Generic() {
    }

    public Generic(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }

}

package fanxing0816;

public class GenericDemo {
    public static void main(String[] args) {

        Generic<String> g1 = new Generic<String>();
        g1.setT("sadad");
        System.out.println(g1.getT());

        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(100);
        System.out.println(g2.getT());
    }
}

泛型方法

格式：public void show(T t){}

public class Generic{
    public <T> void show(T t){
    System.out.println(t);
	}
}

泛型接口

格式：public interface Generic{}

package GenericImpl;

public interface Generic<T> {
    void show(T t);
}

package GenericImpl;

public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

package GenericImpl;

public class GenericImplDemo {
    public static void main(String[] args) {
        GenericImpl<String> gt = new GenericImpl<String>();
        gt.show("asdsadsa");
        GenericImpl<Integer> gt2 = new GenericImpl<Integer>();
        gt2.show(100);
    }
}