Java基础学习

Object类重写ToString方法，equals

Object类是所有类的父类，它包含，toString，hashCode，equals方法等。

import java.util.Objects;
​
public class gg extends Object{
    int x;
​
    @Override
    public boolean equals(Object o) {//idea对java
        if (this == o) return true;
        if (!(o instanceof gg)) return false;
        gg gg = (gg) o;
        return x == gg.x && Objects.equals(y, gg.y);
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
​
    String y;
​
}
pulic static void main(String[] args){
    gg w = new gg();
    gg z = new gg();
    System.out.println(w);//打印对象默认打印tostring方法
    System.out.println(w == z);//判断两个对象是否相同
    System.out.println(w.equals(z));//判断两个对象是否相等（逻辑上进行某些值得比较）
}

Super：可以看作是对父类对象的引用，但是，创建子类对象的过程中并没有创建父类对象，super只是代表了父类的特征。

封装

修饰符	同一个类中	同一个包中	子类	所有类
private	可以调用	不可以	不可以	不可以
default	可以调用	可以调用	不可以	不可以
protected	可以调用	可以调用	可以调用	不可以
public	可以调用	可以调用	可以调用	可以调用

抽象类，多态

多态：是方法的多态，不是属性的多态（多态与属性无关）。同一个方法调用，由于对象不同可能会有不同的行为。多态的存在的三个条件，继承，方法重写，父类引用指向子类对象。

public class Animal {
    public void shout() {
        System.out.println("Animal.shout");
    }
}
class Dog extends  Animal {
    public void shout(){
        System.out.println("汪汪汪！");
    }
    public void watchDoor(){
        System.out.println("Dog.watchDoor");
    }
}
class Cat extends Animal {
    public void shout() {  System.out.println("喵喵喵！");
    }
}
public class TestPolym {
    public static void main(String[] args) {
​
        Dog d = new Dog();
        animalCry(d);
​
        Cat c = new Cat();
        animalCry(c);
​
        //对象的转型
        Animal a = new Dog();
        a.shout();
        ((Dog) a).watchDoor();
​
        //强制转型
        Dog a2 = (Dog) a;
        a2.watchDoor();
        Cat a3 = (Cat)a;  //运行时报错：java.lang.ClassCastException
​
    }
​
    static void animalCry(Animal a) {
        System.out.println("step1");
        a.shout();      //多态的三个必要条件：继承、方法的重写、父类引用指向子类对象
        System.out.println("step2");
    }
}
​

抽象类：使用abstract修饰的方法，没有方法体，只有声明。定义的抽象方法在子类必须具体实现。包含抽象方法的累就是抽象类，通过抽象类我们可以做到严格子类的设计，使子类之间更加通用。有抽象方法的类只能被定义为抽象类，抽象类不能被new，不能被实例化，抽象类可以包含属性、方法、构造方法。但是构造方法不能被用来new实例，只能用来被子类调用。抽象类只能用来被继承。抽象方法必须被实现。

public abstract class Shape {
     public abstract void study();
     public abstract void shout();
}
public class why extends Shape{
    @Override
    public void study() {
        System.out.println("ME爱学习");
    }
​
    @Override
    public void shout() {
        System.out.println("HE喜欢狗");
    }
​
    public static void main(String[] args) {
        why x = new why();
        x.shout();
        x.study();
    }
}

接口

接口实现了，规范与具体的隔离。 规范用抽象类来实现，在jdk8之前接口只能有抽象方法。jdk8之后可以有普通方法。

接口：子类通过implements来实现接口中的规范。接口不能实例化对象，但是可以用于声明引用变量类型。一个类实现了接口，必须实现接口中的所有方法，并且这些方法只能是public修饰。jdk1.8后接口中可以包含普通的静态方法，默认方法和普通属性。1.8之前，接口中只能包含及静态常量，抽象方法。

默认方法：默认方法用default关键字，一个接口中可以有多个默认方法。默认方法也叫扩展方法。子类实现接口时，可以直接调用接口中的默认方法，也可以重写。 接口中同时还可以定义静态方法，静态方法可以通过接口名调用。如果实现类中定义了相同名字的静态方法，那就是完全不同的方法，直接从属于实现类。通过类名调用。

public interface shu {
    void shout();
    int high = 0;
    static void study()
    {
        System.out.println("正在学习");
    }
}
public class shixian implements shu{
    @Override
    public void shout() {
        System.out.println(HE好厉害");
    }
    public static void study(){
        System.out.println("ME也不差");
    }
}
public class Main {
    public static void main(String[] args) {
        shu.study();
        shixian x = new shixian();
        x.shout();
        shixian.study();
    }
}

命名冲突：父类优先，如果父类的方法和接口默认方法名冲突，则父类优先。接口冲突，如果多个接口中默认方法有相同名字，则子类必须重新实现该方法。

内部类

内部类是一种特殊的类，指的是定义在一个类内部的类。实际开发中，为了方便的使用外部类的相关属性和方法，我们通常会定义一个内部类。内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。

内部类：成员内部类，匿名内部类，局部内部类。成员内部类包含非静态内部类和静态内部类。

public class Outer1 {
    private int age = 18;
    public void show(){
        System.out.println("外部类，age："+age);
    }
    //内部类。定义在外部类Outer1里面
    //非静态内部类不能有静态的方法、静态的属性、静态初始化块
    class Inner1 {
        private int id = 10001;
        private int age = 28;
        public  void test1(){
            System.out.println("Inner1.test1");
            System.out.println("内部类的属性，age："+this.age);
            System.out.println("外部类的属性，age："+Outer1.this.age);  //通过：外部类名.this.属性名，访问外部类的属性
            Outer1.this.show();
        }
    }
}
public class TestAnonymousInnerClass {
    public void test(A3 a){
        System.out.println("TestAnonymousInnerClass.test");
        a.run();
    }
    public static void main(String[] args) {
        TestAnonymousInnerClass  tc = new TestAnonymousInnerClass();
​
        //匿名内部类只使用一次！！
        tc.test(new A3() {
            @Override
            public void run() {
                System.out.println("匿名内部类的run()");
            }
        });
​
        tc.test(new A3() {
            @Override
            public void run() {
                System.out.println("TestAnonymousInnerClass.run");
            }
        });
    }
}
interface A3 {
    void run();
}

Arrays:

        System.arraycopy(原数组，起始位置，复制的目标数组，起始复制位置，复制长度);
        Arrays.toString(c);//打印目标数组的每个元素
        Arrays.sort(c);//对数组进行升序排序
        Arrays.binarySearch(c,100);//对数组中的元素下表进行查找返回下标
        Arrays.fill(c,100);//用100填充数组

String：

String：不可变字符序列，位于Java.lang包，Java没有内置的字符串数据类型，而是在标准的Java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例。

String方法	用法，作用
char charAt(int x)	返回字符串中第x个字符
boolean equals（String other）	如果字符串与other相等，返回true；否则返回false；
boolean equalslgnoreCase（String other）	如果字符串与other相等（忽略大小写）
int indexOf（String str）	返回从头开始查找第一个子字符串str在字符串中的位置，找不到返回-1；
lastIndexOf（）	返回从末尾开始查找第一个子字符串str在字符串中的位置
int length（）	返回字符串长度
String replace(char oldChar，char newchar)	返回新串，用newchar替换原字符串的oldchar并返回原字符串
boolean startsWith（String prefix）	如果字符串一prefix开始，则返回true；
boolean endsWith（String prefix）	如果字符串以prefix结尾，返回true；
String substring（int beginIndex）	返回一个新字符串，该串包含从beginIndex到串尾
String substring（int beginIndex，int endIndex）	返回，从beginIndex到 endIndex-1的串
String toLowerCase（）	返回，将原字符串中所有大写字母改为小写
String toUpperCase（）	返回，将源字符串的小写字母改为大写
String trim（）	返回，删除字符串头部和尾部的空格

s.contains（char x）	判断x是否是字符串的子串
Integer . toBinaryString（int x）	将x转为二进制字符串

可变字符序列：

StringBuffer StringBuilder

String是不可变字符序列，StringBuffer和StringBuilder：可变字符序列，方法一样。StringBuffer：线程安全，做线程检查，效率较低。StringBuilder：线程不安全，不做线程同步检查，因此效率较高。

import java.sql.SQLOutput;
​
public class TestStringBuffer {
    static StringBuilder sb = new StringBuilder(52);
    static StringBuffer sb2 = new StringBuffer(63);
    String s ="";
​
    public static void main(String[] args) {
        long num1 = Runtime.getRuntime().freeMemory();//获取jvm剩余内存空间  单位：字节
        long time1 = System.currentTimeMillis();//获取当前时间，单位毫秒：
        sb.append("a");//尾部添加
        String sum = "";
        sb2.insert(0,"wo");//插入
        System.out.println(sb);
        System.out.println(sb2);
        sb.insert(0,"56");
        System.out.println(sb);
        System.out.println(sb.reverse());
        System.out.println(sb2.getClass());
        sb2.delete(0,1);//长度删除，左闭右开
        System.out.println(sb2);
        sb.delete(0,1);
        System.out.println(sb);
        sb.deleteCharAt(0);//指定位置删除
        System.out.println(sb);
        for(int  i = 0;i<5000;i++)
        {
            sum += i;//产生5000个对象
        }
        long num2 = Runtime.getRuntime().freeMemory();
        long time2 = System.currentTimeMillis();
        System.out.println(num1-num2);
        System.out.println(time2-time1);
    }
}

包装类：

Integer: 包装类，八种基本数据类型对应八种包装类，将基本类型包装为对象、

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
folat	Float
double	Double

public class fsja {
    public static void main(String[] args) {
            Integer int1 = Integer.valueOf(100);
            int int2  = int1.intValue();
        System.out.println(int2);
        System.out.println(int1);
            //字符串转
        Integer int3 = Integer.parseInt("12300");
            System.out.println(int3);
            System.out.println(int3.toString());
            System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        fsja.testAutoBox();
    }
    public static void testAutoBox(){
        Integer a = 100;//自动装箱
        int b = a;
        //空指针异常
        //Integer c;
        //int x = c;
        //整形，char型所对应的包装类在自动装箱时，对于-128--127之间的数值会进行缓存处理，提高效率；
        Integer d = 100;
        Integer e = 100;
        Integer f = 200;
        Integer g = 200;
        System.out.println(d == e);
        System.out.println(f == g);
    }
​
}

public class Myinteger {//Integer
    private  int value;
    private static Myinteger[] zu = new Myinteger[256];//常量池
    private static final int low = -128;
    private static final int high = 127;
    static{//静态初始化块
        int i;
        for(i = low; i < high;i++)
        {
            zu[i + (-low)] = new Myinteger(i);
        }
    }
​
    private Myinteger(int i) {
        this.value = i;
    }
    public static Myinteger valueof(int i)
    {
        if(i >= low&&i <= high)
        {
            return zu[i + (-low)];
        }
        else{
            return new Myinteger(i);
        }
    }
    public int getValue()
    {
        return value;
    }
​
    @Override
    public String toString() {
        return "" + value;
    }
​
    public static void main(String[] args) {
        Myinteger x = Myinteger.valueof(100);
        Myinteger c = Myinteger.valueof(100);
        Myinteger d = Myinteger.valueof(200);
        Myinteger e = Myinteger.valueof(200);
        System.out.println(x == c);
        System.out.println(d == e);
    }
}