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

1 数组

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

2 方法重载

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

java 复制代码
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 引用数据类型

java 复制代码
//数据值存储在其他空间中,指向堆内存
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方法

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

构造方法

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

    }
}

6 标准javaBean

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

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

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

插件快速构造

7 字符串

7.1string

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

java 复制代码
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

java 复制代码
 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保存的是字符串变量,里面的值可以修改

java 复制代码
        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

java 复制代码
 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 转换罗马数字案例

java 复制代码
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 泛型

java 复制代码
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

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

java 复制代码
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

java 复制代码
public class Test1 {
        String b="3";
}

Test2.java

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

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

Dog.java

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

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类型转换异常

java 复制代码
        Animal cat = new Cat();
        //向下转型
        Dog dog1 = (Dog)Adog;
        //调用子类独有的方法
        dog1.func();  
instanceof关键字
java 复制代码
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 局部代码块

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

14.2 构造代码块

java 复制代码
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);
        }
}

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

java 复制代码
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 静态代码块

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

java 复制代码
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);
        }
}

普通代码块:每次创建一个对象就执行一次

静态代码块:只要类加载了就会被调用,只会执行一次

java 复制代码
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

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

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

Main.java

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

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

Frog.java

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

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

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

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

java 复制代码
package DEMO1;

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

适配器设计模式

swim.java

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

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

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

Main.java

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

17 内部类

17.1 成员内部类

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

Animal.java

java 复制代码
public class Animal {
        class eye{ }
        private class hand{}
        public hand gethand(){
                return new hand();
        }
}

Main.java

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

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

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 匿名内部类

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

java 复制代码
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,这个类是被临时创建
    }
}

应用:

java 复制代码
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();
    }
}
相关推荐
测试界的酸菜鱼10 分钟前
Python 大数据展示屏实例
大数据·开发语言·python
让学习成为一种生活方式14 分钟前
R包下载太慢安装中止的解决策略-R语言003
java·数据库·r语言
晨曦_子画19 分钟前
编程语言之战:AI 之后的 Kotlin 与 Java
android·java·开发语言·人工智能·kotlin
Black_Friend28 分钟前
关于在VS中使用Qt不同版本报错的问题
开发语言·qt
南宫生42 分钟前
贪心算法习题其三【力扣】【算法学习day.20】
java·数据结构·学习·算法·leetcode·贪心算法
希言JY1 小时前
C字符串 | 字符串处理函数 | 使用 | 原理 | 实现
c语言·开发语言
残月只会敲键盘1 小时前
php代码审计--常见函数整理
开发语言·php
xianwu5431 小时前
反向代理模块
linux·开发语言·网络·git
Heavydrink1 小时前
HTTP动词与状态码
java
ktkiko111 小时前
Java中的远程方法调用——RPC详解
java·开发语言·rpc