JAVA入门基础小结

算术运算符

隐式转换（int取值小 转成 long取值大）

1. byte < short<int <long< flout <double

2. 小变大转换

3. byte short char 三种类型的数据在运算的时候，变为int 进行 计算

强制转换(大变小)

格式：a =( 数据类型 )b

例：double b=10

int a =（int）b

拼接

+号运算有字符串，进行拼接操作

自增自减运算符

a++ |a-- 先用后加减

++a |--a 先加减后用

赋值运算符和关系运算符

a+=b --> a=a+b

同理有-= 、*=、 /=、%=

赋值运算符存在强制转换

关系运算符 ==、!=、>、>=、<=、

逻辑运算符

符号	作用
&	与
|	或
^	异或（相同f||不同t）
!	非

短路逻辑运算符

&& 先判断前者后判断后者 两者为T则为T

|| 先判断前 一个T则为T（左边能确定结果则右边不执行）

三元运算符

接收值 = 表达式 ？ 值T：值F；表达式为True给值T,为false给值F；

优先级

无脑小括号

switch语句

case穿透，必须要有break

jdk12以上可以写成，无需break；

case 1 -> {语句}；
case 2 -> {语句}；

方法重载

1. 在同一个类中，定义了多个同名的方法。这些同名的方法具有同种的功能。

2. 每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系。

   即个数不同 顺序不同 参数类型不同ps：（不看返回类型，只看参数类型个数和函数名）

基本数据类型和引用数据类型

### 内存角度理解

基本数据类型：数据值是存储在自己的空间中（栈内存）

特点：赋值给其他变量，也是赋的真实的值

引用数据类型：数据值是存储在其他空间中，自己空间中存储的是地址值。（堆内存）

面向对象的过程

类和对象

代码:包含两个部分：成员变量和成员方法

public class Phone {
    String brand;
    double price;
    public void call(){
​
        System.out.println("正在打电话；");
    }
    public void playgame(){
        System.out.println("正在玩游戏；");
    }
}

调用规则如下:

 Phone p=new Phone();
        p.brand="小米";
        p.price=1999;
        p.call();
        p.playgame();

• 用来描述一类事物的类，专业叫做：javabean 类。在 javabean 类中，是不写main方法的。

• 在以前，编写main方法的类，叫做测试类。我们可以在测试类中创建 javabean 类的对象并进行赋值调用；

定义注意事项

• 类名首字母建议大写，需要见名知意，驼峰模式。

• 一个Java文件中可以定义多个class类，且只能有一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类。

• 成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值；一般无需指定初始化值，存在默认值。

成员变量和局部变量的区别

封装

对象代表什么，就得封装对应的数据，并提供数据对应的行为。

private

1. private关键字是一个权限修饰符

2. 可以修饰成员(成员变量和成员方法)

3. 被private修饰的成员只能在本类中才能访问

4. 针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

5. 提供“setXxx(参数)”方法，用于给成员变量赋值，方法用public修饰

6. 提供“getXxx()”方法，用于获取成员变量的值，方法用public修饰

this关键字

成员变量和局部变量重名的时候调用就近变量（就近原则）

this的作用可以区别成员变量和局部变量

this的本质是调用方法的内存值

构造方法

构造方法的作用

• 创造对象的时候，由虚拟机自动调用，给成员变量进行初始化的。

构造方法注意事项

1. 构造方法的定义

• 如果没有定义构造方法，系统将给出一个默认的无参数构造方法

• 如果定义了构造方法，系统将不再提供默认的构造方法

1. 构造方法的重载

• 带参构造方法，和无参数构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载

1. 推荐的使用方式

• 无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法

标准的JavaBean类

1. 类名需要见名知意

2. 成员变量使用private修饰

3. 提供至少两个构造方法

   • 无参构造方法

   • 带全部参数的构造方法

4. 成员方法

   • 提供每一个成员变量对应的setXxx()/getXxx()

   • 如果还有其他行为，也需要写上

String类

string初始化值后无法改变值，可用字符数组改变如下：

char[] chs = {'a','b','c','d'};
String s4 = new String(chs);
System.out.println(s4);
//字符数组可以改变，则输出的值可以改变

直接赋值和new赋值内存模型

直接赋值字符串是存在堆内存中的串池（节约内存）

new创建是在堆内存中开辟空间

当使用双引号直接赋值时，系统会检查字符串在串池里面是否存在。

不存在：创建新的

存在：复用

字符串的比较

==号比较的是字符地址，地址相同时即相同，不适应字符串的比较。

字符串比较采用 boolean equals() boolean equalsIgnoreCase(不区分大小写)

String方法

StringBuilder

StringBuilder可以看作是一个容器，创建之后里面的内容是可变的

作用：提高字符串的操作效率

常用方法： public StringBuilder append() //添加数据，返回对象值

public StringBuilder reverse() //反转容器内容值

public int length() //返回容器内字符串的长度

public String toString() //将StringBuilder转化为字符串

链式编程：形容这样 getString().substring(1).replace(A,Q).length();

StringJoiner

StringJoinerr也可以看作是一个容器，创建之后里面的内容是可变的

作用：提高字符串的操作效率

构造方法：

public StringJoiner(间隔符号) 注意：必须是带参构造

public StringJoiner(间隔符号，开始符号，结束符号)

成员方法：

public StringJoiner add(添加的内容) //输出的是包含字符

public int length() //长度包含字符

public String toString() //作用同上

小结

1. 字符串拼接的底层原理

• 如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串。

• 如果有变量参与，每一行拼接的代码，都会在内存中创建新的字符串，浪费内存。

1. StringBuilder提高效率的原理图

• 所有要拼接的内容都会往StringBuilder中放，不会创建很多无用的内存，节约内存。

1. StringBuilder源码分析

• 默认创建一个长度为16的字节数组

• 添加内容长度小于16，直接存

• 添加的内容大于16会扩容（原来容量*2+2）

• 如果扩容之后还不够，以实际长度为准

集合

集合和数组的对比

长度上：集合为可变长度，需要一个即自动扩建一个；数组的长度是不可变的

存储类型：数组两种数据类型都可以存储，而集合只能存储引用数据类型，基本数据类型需要转变为其包装类才能使用

调用方法如下：

    ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.remove("aaa"); //删除指定元素
        list.remove(1); //删除指定位置的元素
        list.set(1,"eee"); //指定位置替换元素
        String str=list.get(1); //查询指定位置元素
        System.out.println(list);

面向对象

static表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量

特点：

• 被该类所有对象共享

• 不属于对象，属于类

• 随着类的加载而加载，优先于对象存在

调用方式：

• 类名调用（推荐）

• 对象名调用

  一般使用时判断成员的属性是否是全员拥有，T则用static修饰

被static修饰的成员方法，叫做静态方法

特点：

• 多用在测试类和工具类中

• Javabean类中很少会用

调用方法：

• 类名调用（推荐）

• 对象名调用

注：工具类 不是用来描述一类事物的，而是帮我们做一些事情的类。（JavaBean类，测试类工具类）

类名见名知意，私有化构造方法，方法定义为静态

工具类代码如下：

public class ArrayUtil {//定义个数组返回形式为[,,]的工具类
    private ArrayUtil(){}//私有化方法
    public static String printArr(int[] arr){//静态方法
        StringBuilder sj = new StringBuilder();//不用strjoin原因，其add方法只能加入字符串
        sj.append("[");
        for(int i =0;i<arr.length;i++){
            if(i==arr.length-1){
                sj.append(arr[i]);//strbuilt可以添加整数
                sj.append("]");
            }else {
                sj.append(arr[i]).append(",");
            }
        }
        return sj.toString();
    }

static注意事项

• 静态方法只能访问静态变量和静态方法

• 非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法

• 静态方法中是没有this关键字

main（）方法

• public：权限足够大，被JVM调用

• static:被JVM调用 main函数无须创建对象（因为main方法是静态的，所以其中的测试方法也是静态的）

• void：被JVM调用无需返回值

• main：一通用的名称，不是关键字，但是能够被JVM识别

• String[] args： 以前用来接收键盘录入数据的，现在没用

继承

1. Java只能单继承：一个类只能继承一个父类。

2. Java不支持多继承、但是支持多层继承。

3. Java中所有的类都直接或者间接继承object类。

4. 子类只能访问父类中非私有的成员。

构造方法：子类不能继承父类的构造方法

成员变量：子类可以继承父类全部成员变量

成员方法：子类不能继承父类私有的成员方法 虚方法表里的方法可以被继承

成员变量

1. 继承中成员变量访问特点： 就近原则

   先在局部位置找，本类成员位置找，本类成员位置找，父类成员位置找，逐级往上

2. System.out.print(name);局部位置开始往上找

   System.out.print(this.name)从本类成员位置开始往上找

   System.out.print(super.name)从父类成员位置开始往上找

成员方法

1. 重写方法的名称、形参列表必须与父类中的一致

2. 子类从写父类方法时，访问权限子类必须大于等于父类（空着不写<protect<public）

3. 子类重写父类方法时，返回值类型子类必须小于等于父类

4. 建议：重写的方法尽量和父类保持一致

5. 只有被添加到虚方法表中的方法才能被重写

成员方法的特点：

• this调用，就近原则

• super调用，直接找父类

方法重写：在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类的这个方法是重写的方法。

@Override注解可以校验重写是否正确，同时可读性好

基本要求：

• 子类重写的方法尽量跟父类中的方法保持一致。

• 只有虚方法表里面的方法可以被重写

方法重写的本质：覆盖虚方法表中的方法

构造方法

继承中构造方法的访问特点：

• 子类不能继承父类的构造方法，但是可以通过super调用

• 子类构造方法的第一行，有一个默认的super()

• 默认先访问父类中无参的构造方法，再执行自己

• 如果想要方法文父类有参构造，必须手动书写

练习

person代码：

public class Person {
    private  String id;
    private String name;
    private int money;
​
    public Person() {
    }
​
    public Person(String id, String name, int money) {
        this.id = id;
        this.name = name;
        this.money = money;
    }
​
    public String getId() {
        return id;
    }
​
    public void setId(String id) {
        this.id = id;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getMoney() {
        return money;
    }
​
    public void setMoney(int money) {
        this.money = money;
    }
    public void work(){
​
    }
    public void eat(){
        System.out.println("吃米饭");
    }
}

Manager代码：

public class Manager extends Person{
    String managermoney;
    public Manager(){
        super();
    }
    public Manager(String id,String name,int money,String managermoney){
        super(id,name,money);
        this.managermoney=managermoney;
    }

    public String getManagermoney() {
        return managermoney;
    }

    public void setManagermoney(String managermoney) {
        this.managermoney = managermoney;
    }
    @Override
    public void work(){
        System.out.println("管理其他人");

    }
}

Cooker代码：

public class Cooker extends Person{
    public Cooker(){
        super();
    }
    public Cooker(String id,String name,int money){
        super(id,name,money);
    }
    @Override
    public void work(){
        System.out.println("炒菜");
    }
}

Test代码：

public class Test {
    public static void main(String[] args) {
        Manager mg1=new Manager("123","小蜗",8000,"100000");
        System.out.println(mg1.getId()+'+'+mg1.getName()+'+'+mg1.getMoney()+'+'+mg1.getManagermoney());
        mg1.work();
        mg1.eat();
        System.out.println("==========");
        Cooker cK1=new Cooker("124","小胡",5000);
        System.out.println(cK1.getId()+'+'+cK1.getName()+'+'+cK1.getMoney());
        cK1.eat();
        cK1.work();
    }
}