JAVA篇01 —— 面向对象基础部分

Echo-Nie

已于 2025-02-01 00:43:30 修改

阅读量1.2k

点赞数 23

分类专栏：学学JAVA 文章标签： java 开发语言

于 2024-11-26 03:30:00 首次发布

本文链接：https://blog.youkuaiyun.com/nyxdsb/article/details/144000553

版权

学学JAVA 专栏收录该内容

17 篇文章

订阅专栏

欢迎来到我的主页：【一只认真写代码的程序猿】

本篇文章收录于专栏【小小爪哇】

如果这篇文章对你有帮助，希望点赞收藏加关注啦

1 JAVA特点

OOP、健壮性、跨平台（一个编译好的.class文可以在多个系统下运行）、解释性语言如JavaScript、PHP、JAVA。编译性语言如c/c++。解释性语言，编译后的代码，不能直接被机器执行,需要解释器来执行, 编译性语言, 编译后的代码, 可以直接被机器执行。

1.1 跨平台

JVM 是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器，包含在JDK 中。对于不同的平台，有不同的虚拟机。Java 虚拟机机制屏蔽了底层运行平台的差别，实现了一次编译，到处运行。

1.2 JDK与JRE与切换JDK

JDK 的全称(Java Development Kit Java 开发工具包)
JDK = JRE + java 的开发工具 [java, javac,javadoc,javap 等]
JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK，就不用在单独安装 JRE 了。

JRE(Java Runtime Environment Java 运行环境)
JRE = JVM + Java 的核心类库[类]
包括 Java 虚拟机(JVM Java Virtual Machine)和 Java 程序所需的核心类库等，如果想要运行一个开发好的 Java 程序，计算机中只需要安装 JRE 即可。

JDK = JRE + 开发工具集（例如 Javac,java 编译工具等)
JRE = JVM + Java SE 标准类库（java 核心类库）

切换不同版本jdk：更改JAVA_HOME即可，cmd中输入java -version

1.3 JAVA执行流程

将 Java 代码编写到扩展名为 Hello.java 的文件中。
通过 javac 命令对该 java 文件进行编译，生成 .class 文件。
通过 java 命令对生成的 class 文件进行运行。

执行入口是psvm；严格区分大小写；一个源文件中只能用一个public类且与类名相同；可以将main写在非public类中，这样入口就是非public的main。

1.4 常用转义&IDE注释

public class ChangeChar{
    public static void main(String[] args){
        //  \t:一个制表位
        System.out.println("北京\t天津\t上海");
        //  \n:一个换行符
        System.out.println("jack\nsmith\n");
        //  \\:一个\
        System.out.println("C:\\Windows\\System32\\cmd.exe");
        // \":一个"
        System.out.println("我说\"要好好学习JAVA\"");
        // \':一个'
        System.out.println("我说\'要好好学习JAVA\'");
        // \r:一个回车
        //只输出\r后面的内容（jdk21）
        System.out.println("hhh123\r\n哈哈1");
    }
}

2 变量与输入

“+”运算规则：加了字符串则全是字符串

        System.out.println(123+11);//134
        System.out.println("123"+11);//12311
        System.out.println(123+"111");//123111
        System.out.println(123+"111"+2);//1231112

PS：

整型默认是int；声明long要加L或l；上图是byte和short的内存形式。

浮点默认是double，声明float要在后面加f或F。

浮点数比较：Math.abs(num1-num2)<0.000001 sout("差值很小，认为相等");

字符：

字符常量是用单引号( '’)括起来的单个字符。例如:char c1 ='a'; char c2 ='中':char c3 = '9';
Java中还允许使用转义字符八'来将其后的字符转变为特殊字符型常量。例如:charc3='\n’;
在java中，char的本质是一个整数字符输出97 -> a
char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码.

Boolean：

只有true和false，没有null，boolean占一个字节。

2.1 自转和强转

多种数据类型混合运算的时候，系统先自动将所有数据转换成容量最大的那种，再计算。byte、short、char之间不会自动类型转换。但是这三者在混合计算的时候会首先转为int类型再计算。boolean不参与转换。

自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符()，但可能造成精度降低或溢出。

2.2 基本数据类型和String

基本类型转String用“+”运算符即可，String转基本类型用打包的parseXX即可。

String 转 char，str.charAt(index);

        int n1 = 100;
        float n2 = 1.1f;
        double n3 = 1.2;
        boolean n4 = true;
        String str1 = n1 + "";
        String str2 = n2 + "";
        String str3 = n3 + "";
        String str4 = n4 + "";
        //1001.11.2true
        System.out.println(str1 + str2 + str3 + str4 + "\n");
        int n11 = Integer.parseInt(str1);
        System.out.println(n11);//100


        String str = "12345";
        System.out.println(str.charAt(0));//1

2.3 运算

2.4 输入

Scanner在java,util包下，手搓时记得导包。

import java.util.Scanner;
public class Test{
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        System.out.println(n);
    }
}

3 switch和if

如果判断的具体数值不多且符合byte、short、int、char、enum、String则使用switch，否则用if。

break是退出当前的循环体，也可以使用break label: ；但是不建议。

4 数组

赋值：int [] arr1={1,2,3}; int []arr2=arr1;

拷贝：int []arr1={1,2,3}; int [] arr2=new int[arr1.length]; for循环赋值

反转：for(i;i<len/2;i++) 交换arr[i]和arr[len-1-i];或者逆序赋值法

扩容：原始数组静态分配int []arr={1,2,3};增加数字4；新建int[]arrNew = new int[arr.len+1];循环赋值给arrNew再插入arrNew[arrNew.len-1]=4;再让arr指向arrNew。

二维动态初始化：

int[][] arr = new int[3][];
for(int i = 0; i < arr.length; i++) {
    arr[i] = new int[i + 1];

    for(int j = 0; j < arr[i].length; j++) {
            arr[i][j] = i + 1;
    }
}

5 类

5.1 内存结构

类是抽象的，概念的，代表一类事物,比如人类,猫类.., 即它是数据类型.

对象是具体的，实际的，代表一个具体事物, 即是实例.

类是对象的模板，对象是类的一个个体，对应一个实例

Java 内存的结构分析：

栈：一般存放基本数据类型(局部变量)
堆：存放对象(Cat cat , 数组等)

方法区：常量池(常量，比如字符串)，类加载信息

5.1 方法调用机制

成员方法的好处：

提高代码复用性。
将实现细节封装起来，供其他用户调用即可。

5.2 方法传参

基本数据类型是“值拷贝”；形参不影响实参。

引用类型传递的是地址(传递也是值，但是值是地址)，可以通过形参影响实参。

5.3 方法重载

方法名字相同，形参列表不同（个数、类型、顺序不同均可）。返回类型无要求。

如下：

calculate(int n1, int n2)
calculate(int n1, double n2)
calculate(double n2, int n1)
calculate(int n1, int n2,int n3)

5.4 方法重写Override

方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的方法。

5.5 可变参数

java 允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现。

访问修饰符返回类型方法名(数据类型... 形参名) {

}

public int sum(int... nums) {
    //System.out.println("接收的参数个数=" + nums.length);
    int res = 0;
    for(int i = 0; i < nums.length; i++) {
        res += nums[i];
    } 
    return res;
}

/**
 * 有三个方法，分别实现返回姓名和3门课成绩(总分)，
 * 返回姓名和5门课成绩(总分)，
 * 返回姓名和8门课成绩(总分)。封装成一个可变参数的方法
 */
public class VarParameter {
    public static void main(String[] args) {
        VarParaMethod vpm = new VarParaMethod();
        System.out.println(vpm.showScore("小明",99,100,97));
        System.out.println(vpm.showScore("小刚",99,100,97,98,100));
        System.out.println(vpm.showScore("小刚",99,100,97,98,100,98,97,90));
    }
}
class VarParaMethod{
    public String showScore(String name,double...scores){
        double total=0;
        for(int i=0;i<scores.length;i++){
            total+=scores[i];
        }
        return name+"同学"+"有"+scores.length+"门课，总分为："+total;
    }
}

5.6 作用域

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

class Cat {
    //全局变量：也就是属性，作用域为整个类体 Cat 类： cry eat 等方法使用属性
    //属性在定义时，可以直接赋值
    int age = 10; //指定的值是 10
    //全局变量(属性)可以不赋值， 直接使用， 因为有默认值，
    double weight; //默认值是 0.0

    public void hi() {
        //局部变量必须赋值后，才能使用， 因为没有默认值
        int num = 1;
        String address = "北京的猫";
        System.out.println("num=" + num);
        System.out.println("address=" + address);
        System.out.println("weight=" + weight);//属性
    }

    public void cry() {
        //1. 局部变量一般是指在成员方法中定义的变量
        //2. n 和 name 就是局部变量
        //3. n 和 name 的作用域在 cry 方法中
        int n = 10;
        String name = "jack";
        System.out.println("在 cry 中使用属性 age=" + age);
    }

    public void eat() {
        System.out.println("在 eat 中使用属性 age=" + age);
        //System.out.println("在 eat 中使用 cry 的变量 name=" + name);//错误
    }
}

属性和局部变量可以重名，访问时遵循就近原则。
在同一个作用域中，比如在同一个成员方法中，两个局部变量，不能重名。
伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变属性生命周期较长，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁量，生命周期较短，即在一次方法调用过程中。
作用域范围不同:
全局变量/属性:可以被本类使用，或其他类使用(通过对象调用)
局部变量:只能在本类中对应的方法中使用
修饰符不同全局变量/属性可以加修饰符局部变量不可以加修饰符

5.7 权限修饰符

java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围） :

公开级别:用 public 修饰,对外公开
受保护级别:用 protected 修饰,同一个包下or子类
默认级别:没有修饰符号,同一个包的类公开.
私有级别:用 private 修饰,只有类本身可以访问,不对外公开

1	访问级别	修饰符	同类	同包下	子类	不同包
2	公开的	public	√	√	√	√
3	受保护	protected	√	√	√
4	默认	无/default	√	√
5	私有	private	√

注意：

修饰符可以用来修饰类中的属性，成员方法以及类2，并且遵循上述访问权限的特点。

只有默认的和public才能修饰类！

6 面向对象三大特征

6.1 封装

封装（encapsulation）就是把抽象的数据【属性】和对数据的操作【方法】封装在一起，数据被保护在内部，程序的其他部分只能通过被授权的操作【方法】，才能对数据进行操作。

大白话：把属性通过private进行私有化，分别提供public的set方法（对属性进行判断和赋值）和get方法（获取属性的值）。

6.2 继承extends

提高代码复用性、可扩展性、维护性。

继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来声明继承父类即可。
class 子类 extends 父类{

}
1)子类就会自动拥有父类定义的属性和方法

2)父类又叫 超类，基类。

3)子类又叫派生类。

public class ExtendsDetail {
    public static void main(String[] args) {
        Base base = new Base();
        //TopBase和Base的构造器都被调用

    }

}

class Base extends TopBase {
    public int n1 = 100;

    public Base() {
        //默认super()
        System.out.println("Base Structure is used...");
    }

    public Base(int n) {
        //默认super();
        System.out.println("Base Parameter Structure is used...");
    }
}

class TopBase {
    public TopBase() {
        System.out.println("TopBase Structure is used...");
    }
}

6.3 继承的内存布局

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();//内存的布局
        //?-> 这时请大家注意， 要按照查找关系来返回信息
        //(1) 首先看子类是否有该属性
        //(2) 如果子类有这个属性， 并且可以访问， 则返回信息
        //(3) 如果子类没有这个属性， 就看父类有没有这个属性(如果父类有该属性， 并且可以访问， 就返回信息..)
        //(4) 如果父类没有就按照(3)的规则， 继续找上级父类， 直到 Object...
        System.out.println(son.name);//返回就是大头儿子
        //System.out.println(son.age);//返回的就是 39
        //System.out.println(son.getAge());//返回的就是 39
        System.out.println(son.hobby);//返回的就是旅游
    }
}

class GrandPa { //爷类
    String name = "大头爷爷";
    String hobby = "旅游";
}

class Father extends GrandPa {//父类
    String name = "大头爸爸";
    private int age = 39;

    public int getAge() {
        return age;
    }
}

class Son extends Father { //子类
    String name = "大头儿子";
}

6.4 Super

super 代表父类的引用，用于访问父类的属性、方法、构造器

1.访问父类的属性，但不能访问父类的private属性。super.属性名;

2.访问父类的方法，不能访问父类的private方法super方法名(参数列表);
3.访问父类的构造器，super(参数列表);只能放在构造器的第一句，只能出现一句,

No.	区别	this	super
1	访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	从父类开始查找属性
2	调用方法	访问本类中的方法,如果本类没有此方法则从父类继续查找.	从父类开始查找方法
3	调用构造器	调用本类的构造器，必须在构造器首行	调用父类构造器，必须在子类构造器首行
4	特殊	当前对象	子类访问父类对象

6.5 多态

是JAVA中比较重要的一个概念，所以另起一篇来介绍。传送门：

JAVA多态-蜡笔小新.-优快云博客

7 Object类

Object类-蜡笔小新.-优快云博客

8 一些简单递归（后续补充）

PS：基本功

PS1 进制

二进制： 0,1 ，满 2 进 1.以 0b 或 0B 开头。

十进制： 0-9 ，满 10 进 1。
八进制： 0-7 ，满 8 进 1. 以数字 0 开头表示。
十六进制：0-9 及 A(10)-F(15)，满 16 进 1. 以 0x 或 0X 开头表示。此处的 A-F 不区分大小写。

public class Test{
    public static void main(String[] args) {
        int n2 = 0b1010;
        int n8 = 01010;
        int n10 = 1010;
        int n16=0X1010;
        System.out.println("n2="+n2);//10
        System.out.println("n8="+n8);//512+8=520
        System.out.println("n10="+n10);//1010
        System.out.println("n16="+n16);//4112
    }
}