JAVA基础：数组、重载、数据类型、封装、字符串、静态、继承、重写、多态、代码块、权限、接口、内部类

1 数组

//静态初始化
int[] arr1=new int[]{1,2,3,4}
//简化形式
int[] arr2={1,2,3,4}
//动态初始化
int[] arr3=new int[5]

2 方法重载

在同一个类中的多个方法的方法名相同,参数个数不同，参数类型不同，参数类型顺序不同

public class Test1 {
        public static void main(String[] args) {
                Animal animal = new Animal();
                animal.m(1);
                animal.m(1.1);
                animal.m(1,1.1);
                animal.m(1.1,1);
        }
}
class Animal{
        public void m(int n){
                System.out.println("int");
        }
        public void m(double n){
                System.out.println("float");
        }
        public void m(int n,double m){
                System.out.println("int n,float m");
        }
        public void m(double m,int n){
                System.out.println("float m,int n");
        }
}

3 数据类型

3.1 基本数据类型

//数据值存储在自己空间中
int a=1;

3.2 引用数据类型

//数据值存储在其他空间中,指向堆内存
int[] arr=new int[]{1,2,3};
//传递的地址值
int[] arr1=arr;

4 IDEA

编写代码：project->module->packege->class，自动保存和编译

快捷键：

sout：

System.out.println();

psvm：

public static void main(String[] args) {
    
}

5 封装

私有变量+get、set方法

public class Object {
//成员变量
    private String name;
    private int age;
    public void setAge(int  n){
//局部变量
        int b=1;
        if(n>=18&&n<=50){
            age = n;
        }else{
            System.out.println("非法参数");
        }

    }
    public int getAge(){
    return age;
    }
}

public void setAge(int  age){
        if(n>=18&&n<=50){
            //自己传递给自己
            age = age;
            //把值传递给成员变量的age
            //age就近原则，this是调用者的地址值，所以this===对象类new声明的变量
            this.age=age;
        }else{
            System.out.println("非法参数");
        }
    }

构造方法

public class Object {
    //    方法名与类名相同，没有返回值，由虚拟机在创建对象的时候自动调用
    public Object() {

    }
}

6 标准javaBean

成员变量private，且提供set、get

至少两个构造方法：1 无参构造 2有全部参数构造

alt+insert：要有空参构造和全参构造

插件快速构造

7 字符串

7.1string

是java定义好的类，定义在java.lang包，使用不需要导包

public Object() {
    }
//当使用双引号直接赋值，会查该字符串在串池是否存在

//存在：复用，指向相同地址

//不存在：创建新的

    String s1="abc";
    String s2=new String();
    String s3=new String("123456");
    char[] c={'1','2','3'};
    //s4与s6指向地址不同
    String s4=new String(c);
    String s6=new String(c);
//    字节数组转为字符串
    byte[] b={12,13,14};
    String s5=new String(b);
//表示内容相等么？
    boolean b1=s5.equals(s4);
    boolean b2=s5.equalsIgnoreCase(s4);
}

7.2 StringBuilder

 public static void main(String[] args) {
        //    创建一个可变字符串对象
        StringBuilder sb=new StringBuilder("abc");
        sb.append("de");
        System.out.println(sb);//abcde
        sb.reverse();
        System.out.println(sb);//edcba
//       容量
       sb.capacity();
//       容量内字符串长度
       sb.length();
    }

源码分析：默认创建一个长度16的字节数组，大于16会扩容

7.3 StringBuffer

String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址,String是被final修饰的类，不能被继承

StringBuffer保存的是字符串变量，里面的值可以修改

        String s1=new String("");
        StringBuffer sb=new StringBuffer();
        System.out.println(s1);//空
//        打印的是属性值
        System.out.println(sb);//1
//        每次加一个值
        sb.append(1);
        sb.reverse();
        System.out.println(sb);
//        把StringBuffer变为字符串
        String str=sb.toString();

7.4 StringJoiner

 StringJoiner sj=new StringJoiner("---");
        sj.add("111").add("222");
        System.out.println(sj);//111---222
        StringJoiner sj1=new StringJoiner("---","[","]");
        sj1.add("111").add("222");
        System.out.println(sj1);//[111---222]

拼接：

JDK8之前StringBuilder的append()方法

JDK8之后预估string拼接后大小，然后把内容放入数组，产生一个新字符串

==比较的是？

引用数据类型比较地址值

基本数据类型比较数据值

7.5 转换罗马数字案例

package DEMO1;

import java.util.Scanner;

public class Object {
    public static void main(String[] args) {
        String s;
        Scanner sc=new Scanner(System.in);
        while (true){
            s=sc.next();
            if(check(s))
            {
                break;
            }else {
                System.out.println("error");
                continue;
            }
        }
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<s.length();i++)
        {
            char c=s.charAt(i);
            sb.append(change(c-48));
        }
        System.out.println(sb);
       }
       public static String change(int number){

           String arr[] = {"","Ⅰ","Ⅱ","Ⅲ","Ⅳ","Ⅴ","Ⅵ","Ⅶ","Ⅷ","Ⅸ"};
            return arr[number];
       }

       public static boolean check(String s){
        if(s.length()>9)
        {
            return  false;
        }
        for(int i=0;i<s.length();i++)
        {
            char c=s.charAt(i);
            if(!(c>'0'&&c<'9'))
                return  false;
        }
           return true;
       }
}

7.6 泛型

public class Test1 {
        public static void main(String[] args) {
//                泛型：限定集合中存储的数据类型
//                打印的是内部数据内容
//                不能放基本数据类型，string是引用数据类型
                ArrayList<String> list=new ArrayList<>();
                list.add("aaa");
                list.add("bbb");
                list.add("ccc");
                list.add("ddd");
                list.remove("ccc");
                System.out.println(list);
//                删除1索引的数值是第二个值
                list.remove(1);
                System.out.println(list);
//                修改
                list.set(1,"eee");
                System.out.println(list);
//                遍历
                for(int i=0;i<list.size();i++)
                {
                        String str=list.get(i);
                        System.out.println(str);
                }
        }
}

8 static变量

修饰成员方法、成员变量

被所有类所共享，不属于特定对象

推荐用类名调用，也可以用对象名调用

静态变量是随着类加载而加载，优先于对象出现

堆内存

工具类：不描述具体事物，而是做事情的类

私有化构造方法，不让外界创建其对象

方法定义为静态，静态方法没有this关键字

9 继承

java只支持单继承，不支持多继承，但支持多重继承

所有类都继承object类

子类不可以继承父类所有构造方法，能继承父类所有成员变量，能继承非私有的成员方法

父类、子类都有自己的虚方法表，包括非private、非static、非final

只有父类虚方法才能被子类继承和重写

public class student {
    String name;
    int age;
//    表示当前调用者的地址值
//    this是由虚拟机赋值的,而不能手动赋值
    public void show1(student this){
        System.out.println(this);
//        相当于this.name
        System.out.println(name);
    };
}

studentTest
public class studentTest {
    public static void main(String[] args) {
        student s1=new student();
        System.out.println(s1);
        s1.show1();
    }
    }

调用子类父类的方法或声明

Test1.java

public class Test1 {
        String b="3";
}

Test2.java

public class Test2 extends Test1{
    public static void main(String[] args) {
        Test2 t2=new Test2();
        t2.func();
    }
    String c="2";

    public  void func() {
        System.out.println(c);//2
        System.out.println(b);//3
        System.out.println(super.b);//3
        System.out.println(this.b);//3
    }
}

成员变量访问特点：就近原则

10 重写

重写的方法名称、形参必须与父类一致，权限>父类（public>protected>不写），返回值类型<=父类

方法的重载是方法的参数个数或种类或顺序不同，方法名相同

快捷键：

11 多态

前提；1 有继承 2 有重写 3 父类引用指向子类对象

多态成员变量：编译运行看左边

方法：编译看左边，运行看右边

Animal.java

public class Animal {
        public int age=20;
        public static void sleep(){
                System.out.println("动物在睡觉");
        }
        public void func() {
                System.out.println("我是animal");
        }
}

Dog.java

package DEMO1;

public class Dog extends Animal{
    public int age=18;
    public static void sleep(){
        System.out.println("dog在睡觉");
    }

    @Override
    public void func() {
        super.func();
        System.out.println("我是dog");
    }
    public void eat(){
        System.out.println("dog吃饭");
    }

}

Test1.java

package DEMO1;

public class Test1 {
        public static void main(String[] args) {
                Animal animal = new Animal();
                animal.func();
                Dog dog=new Dog();
                dog.func();
                Animal Adog=new Dog();
//                子父类存在同名的非静态成员方法时，访问的是子类中重写的方法
                Adog.func();//我是dog
//                多态情况下，子父类存在同名的静态成员变量成员方法时，访问的是父类的成员函数
                Adog.sleep();//动物在睡觉
//                多态情况下，子类和父类存在同名的成员变量时，访问的时父类的成员变量
                System.out.println(Adog.age);//20
//                多态情况下，不能访问子类独由的方法
//                Adog.eat();
//                向下转型
                Dog dog1=(Dog)dog;
                dog1.func();//我是dog
        }
}

报错问题：将子类Cat的对象cat变成了兄弟类的对象dog,这就不是向下转型，因此会报ClassCastException类型转换异常

        Animal cat = new Cat();
        //向下转型
        Dog dog1 = (Dog)Adog;
        //调用子类独有的方法
        dog1.func();

instanceof关键字

Animal Adog=new Dog();
                if(Adog instanceof cat)
                {
                        cat ca=(cat)Adog;
                        ca.func();//我是animal
                }else if(Adog instanceof Dog)
                {
                        Dog dog2=(Dog) Adog;
                        dog2.func();//我是dog
                }

12 包和final

12.1 包

包是文件夹，管理不同java类

名称：公司域名反写+包的作用

使用java.lang包的类，不需要导包

12.2 final

不能重写、继承，常量

final 基本类型：数据不能改变

final 引用类型：（数组）地址值不能改变，内部数据可以改变

常量：全部大写，多个单词用'_'隔开

13 权限修饰符

14 代码块

14.1 局部代码块

        public static void main(String[] args) {
                {
                        int a=1;
                        System.out.println(a);
                }
//                代码块执行完，a占用的内存就清除，现在基本用不到
        }

14.2 构造代码块

public class Test1 {
//        多个构造方法重复的代码写在构造方法块
//        构造方法块优于构造方法执行
        {
                System.out.println("我是老大");
        }
        public Test1(){
                System.out.println("我是老二");
        }
        public Test1(int a){
                System.out.println("我是老三");
        }

        public static void main(String[] args) {
        Test1 te=new Test1();
        Test1 te1=new Test1(2);
        }
}

节省重复代码第二种方式：

public class Test1 {
        public Test1(){
                System.out.println("我是老二");

        }
        public Test1(int a){
                this();
                System.out.println("我是老三");
        }

        public static void main(String[] args) {
        Test1 te=new Test1(2);
        }
}

14.3 静态代码块

创建子类对象实例，父类也会被加载，父类先被加载，子类后被加载

public class Test1 {
        public static void main(String[] args) {
                System.out.println(B.n1);
        }
}
class A{
        public static int n2=20000;
        static{
                System.out.println("1");
        }
}
class B extends A{
        public static int n1=10000;
        static {
                System.out.println(n2);
        }
}

普通代码块:每次创建一个对象就执行一次
静态代码块:只要类加载了就会被调用,只会执行一次

public class Test1 {
        public static void main(String[] args) {
                System.out.println(A.n2);
                A a=new A();
        }
}
class A{
        public static int n2=20000;
        static{
                System.out.println("静态代码块被调用");
        }
        {
                System.out.println("普通代码块被调用");
        }
}

类什么时候被加载:

1 new:A a = new A();

2 使用类的静态成员:静态成员，静态方法

15 抽象类

Animal.java

package DEMO1;
//抽象类不能被实例化
public abstract class Animal {
        private int age;
        //初始化父类成员使用
        public Animal(){
                this.age=age;
        }
        public void sleep(){
                System.out.println("动物在睡觉");
        }
        //只有方法的定义，没有方法的实现
        //有抽象方法，那么这个类必定是一个抽象类
        //抽象类里面可以没有抽象方法
        public abstract void eat();
}

Dog.java

public class Dog extends Animal{
    //所有非抽象子类必须重写抽象类中的抽象方法
    @Override
    public void eat() {
        System.out.println("我是dog");
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        Dog do1=new Dog();
        do1.eat();
        do1.sleep();
    }
}

16 接口

Temnal->jps-> jhsdb hsdb 打开内存分析工具->file->

Swim.java

public interface Swim {
    //默认加上public static final
    int a=10;
    //默认加上public abstract
    void method();
    public abstract void swim();
}

Frog.java

//要么重写所有抽象方法要么抽象类
public class Frog extends Animal implements Swim{
//    不加构造无法赋值
    public Frog(int age) {
        super(age);
    }

    public Frog(int age, String name) {
        super(age, name);
    }

    public Frog() {
    }

    public Frog(String name) {
        super(name);
    }

    @Override
    public void eat() {
        System.out.println("青蛙吃");
    }

    @Override
    public void method() {
        System.out.println("method");
    }

    @Override
    public void swim() {
        System.out.println("青蛙游泳");
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
    Frog fr=new Frog(18,"青蛙");
    System.out.println(fr.getAge()+fr.getName());
    fr.eat();
    fr.swim();
    }
}

实现多个接口的同名方法，重写一次即重写了各个接口的方法

接口与接口，可以单继承，也可以多继承

Swim.java

package DEMO1;

public interface Swim {
//    public 可以省略，default不能省略
    //接口在进行扩展的时候，不会破坏与接口相关的实现类代码
    public default void method1(){
        System.out.println("method1没有重写Swim");
    };
    public default void method2(){
        System.out.println("method2有重写");
    };
    public static void jing(){
        System.out.println("我是静态");
        add();
    };
    private static void add(){
        System.out.println("静态的私有方法，节省代码");
    }

}

Frog.java

package DEMO1;
//要么重写所有抽象方法要么是抽象类
public class Frog  implements Swim{
    @Override
    public void method1() {
        System.out.println("haha");
    }
    @Override
    public void method2() {
        System.out.println("method2重写");
    }
}

Main.java

package DEMO1;

public class Main {
    public static void main(String[] args) {
    Frog fr=new Frog();
//    实现的接口中存在相同名字默认方法，必须重写
    fr.method1();
    fr.method2();
    Swim.jing();
    }
}

适配器设计模式

swim.java

package DEMO1;

public interface Swim {
public abstract void  swim1();
public abstract void  swim2();
    public abstract void  swim3();
    public abstract void  swim4();
    public abstract void  swim5();
    public abstract void  swim6();
    public abstract void  swim7();
    public abstract void  swim8();
}

Rubbit.java

package DEMO1;

public class Rubbit implements Swim{
    @Override
    public void swim1() {

    }
    @Override
    public void swim2() {

    }
    @Override
    public void swim3() {

    }
    @Override
    public void swim4() {

    }
    @Override
    public void swim5() {

    }
    @Override
    public void swim6() {
    }
    @Override
    public void swim7() {
    }
    @Override
    public void swim8() {
    }
}

Frog.java

public class Frog  extends Rubbit {
    @Override
    public void swim5() {
        System.out.println("我只用swim接口的5");
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
    Frog fr=new Frog();
    fr.swim5();
    }
}

17 内部类

17.1 成员内部类

JDK16之前不能定义静态变量，JDK16之后才可以定义静态变量

Animal.java

public class Animal {
        class eye{ }
        private class hand{}
        public hand gethand(){
                return new hand();
        }
}

Main.java

public class Main {
    public static void main(String[] args) {
    Animal.eye ae=new Animal().new eye();
//    hand不能用上面的方法new
    Animal animal=new Animal();
        System.out.println(animal.gethand());//DEMO1.Animal$hand@682a0b20
    }
}

outer this是隐含的

17.2 静态内部类

Animal.java

package DEMO1;

public class Animal {
        public int a=1;
        public static  int b=2;
        static class eye{
               public static void show(){
               Animal an=new Animal();
               System.out.println(an.a);
               System.out.println(b);
               }
                public  void show1(){

                        System.out.println("3");
                }
        }
}

Main.java

package DEMO1;

public class Main {
    public static void main(String[] args) {
        Animal.eye.show();
//        Animal.eye.show1();show1不是静态方法，错误
        Animal.eye ae=new Animal.eye();
        ae.show1();
    }
}

17.3 局部内部类

类中函数里定义的类

17.4 匿名内部类

匿名内部类不能是抽象的，只能也必须继承一个类或者实现一个接口，无构造，无静态

public class Main {
    public static void main(String[] args) {
// swim是接口，{}是匿名类,实现了Swim()这个接口，new的是匿名类
// Swim是抽象类，那么{}是其子类，new表示创建没有名字的对象
        new Swim(){
            @Override
            public  void  swim(){
                System.out.println("1");
            };
        }.swim();//1
        Swim sw=new Swim() {
            @Override
            public void swim() {
                System.out.println("2");
            }
        };
        sw.swim();//2
        System.out.println(sw.getClass());//获取类名class DEMO1.Main$2,这个类是被临时创建
    }
}

应用：

package DEMO1;

public class Main {
    public static void main(String[] args) {
        fun(
                new A(){
                    @Override
                    public void eat() {
                        System.out.println("eat");
                    }
                }
        );//eat
    }
    public static void fun(A s){
        s.eat();
    }
    interface A{
        public void eat();
    }
}