Java基础-CSDN博客

本文链接：https://blog.csdn.net/songwt930/article/details/114312467

Java基础

打开cmd

开始–系统–命令提示符
win+R 输入cmd
任意文件夹下，按shift+鼠标右击，在此处打开窗口
任意文件夹地址前加cmd+空格

管理员方式：选择以管理员方式运行

常用的DOS命令

#盘符切换 E:
#查看文件夹下的文件 dir
#切换目录 cd change directory
#返回上一级目录 cd..
#清屏 cls  (clear screen)
#退出终端 exit
#查看ip ipconfig

#打开应用
calc 计算机
mspaint 画图
notepad 文档

#创建文件夹 md 文件夹名
#移除文件夹 rd 文件夹名
#创建文件 cd>a.txt
#删除文件 del a.txt

计算机语言发展史

机器语言–汇编语言–高级语言

高级语言大体上分为：

面向过程 C
面向对象 Java C++

C语言：

1972年诞生
- 贴近硬件，运行极快，效率极高
- 操作系统，编译器，数据库，网络系统
- 指针和内存管理

C++：

1982年诞生
- 面向对象
- 兼容C
- 图形领域，游戏等

Java：

1995年诞生

三高：高可用、高性能、高并发

Java特性和优势

简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性

Java三大版本

Write Once 、Run Anywhere

JavaSE：标准版（桌面程序，控制台开发。。。）
JavaME：嵌入式开发（手机，小家电。。。）
JavaEE：E企业级开发（web端，服务器开发。。。）

JDK、JRE、JVM

JDK : Java Development Kit

JRE : Java Runtime Environment

JVM : Java Virtual Machine

在这里插入图片描述

JDK安装与卸载

卸载：

删除java安装目录
删除JAVA_HOME
删除path下关于java的目录
cmd进命令行输入java -version测试

安装：

搜索jdk8 ，下载地址
同意协议，下载电脑对应的版本
双击安装，下一步，选择安装路径，不能有中文
记住安装的路径
配置环境变量
1. 我的电脑–右击属性
2. 高级系统设置–环境变量
3. 添加JAVA_HOME(安装路径)
4. 配置path变量–%JAVA_HOME%\bin，%JAVA_HOME%\jre\bin
检查
1. 打开cmd
2. java -version，出现java版本就说明安装成功

Hello World

创建一个java文件
- 文件后缀名为.java
- Hello.java
- 【注意】文件后缀名要打开

编写代码

public class Hello{
	public static void main(String[] args){
		System.out.println("Hello World");
	}
}

注意：文件名与类名要一致Hello.java、class Hello，注意大小写

编译javac java文件，会生成一个.class文件
运行.class文件，java class文件

在这里插入图片描述

Java程序运行机制

编译型：
- 一本小说，全部翻译，然后在看
解释型
- 一本小说，作者更新一章，翻译一章，看一章

在这里插入图片描述

java，先编译，在解释

数据类型

强类型语言

要求变量的使用严格符合要求，所有的变量都必须先定义后才能使用

弱类型语言

Java的数据类型分为两大类

基本数据类型
- 数值类型
  - 整数类型
    - byte占一个字节（-128~127）
    - short占2个字节（-32768~32767）
    - int占4个字节（-2147483648~2147483647）
    - long占8个字节（-9223372036854775808~9223372036854775807）
  - 浮点类型
    - float占4个字节
    - double占8个字节
  - 字符类型
    - char占8个字节
- Boolean类型，占1位值只有true和false
引用数据类型
- 类
- 接口
- 数组

什么是字节：

位（bit）：是计算机内部数据存储的最小单位，11001100是一个八位二进制数
字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B表示
1B（byte，字节）= 8bit（位）
字符：是指计算机中使用的字母、数字、字和符号

1bit表示1位
1Byte表示一个字节 1B=8b
1024B=1KB
1024KB=1M
1024M=1G

注意

在这里插入图片描述

类型转换：

由低------------------------------------->高

byte，short，char --> int --> long --> float --> double

强制转换：（类型）变量名高 – > 低

自动转换：低 --> 高

注意

不能对布尔值进行转换
不能把对象类型转换为不相干的类型
在把高容量转换到低容量的时候，强制转换
转换的时候可能出现内存溢出，或者精度问题

变量

可变化的量
Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

注意事项：

每个变量都有类型，类型可以是基本类型，也可以是引用类型
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每一个生命都必须以分号”；“结束

变量的作用域：

类变量：static变量
实例变量：从属于类，方法之上
局部变量：方法内

顺序结构

Java的借本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行

顺序结构是最简单的算法结构

语句域语句之间，框与框之间是按照从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，

它是任何一个算法都离不开的一种基本算法结构

选择结构

if单选结构
if双选结构
if多选结构
嵌套的if结构
switch多选结构

Java方法详解

值传递和引用传递

值传递：只要是基本类型传递都是值传递
- 值转递，指的是方法调用时，复制一份实际参数（基本类型的值或者引用对象）到方法参数中。这样在方法中参数变更了，不影响实际参数
引用传递：针对于基本类型进行封装，对封装进行传递，是引用传递。
- 引用传递，指方法调用时，直接将实际参数传递到方法参数中，对方法参数的变更，会影响实际参数。

概念中的实际参数和方法参数指的是基本类型的值或者引用对象。引用对象是引用本身，不是引用对象所指向的实际对象。

递归

递归就是：A方法调用A方法，自己调用自己！

递归结构包括两个部分：

递归头：什么时候不调用自身方法，如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法

数组

特点：

长度是固定的。一旦被创建，它的大小是不可变的
其元素必须是相同类型，不允许出现混合类型
数组中的元素可以是任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

内存分析

在这里插入图片描述

冒泡排序：

//冒泡排序
public static int[] sort(int[] array) {
    int temp = 0;
    for (int i = 0; i < array.length-1; i++) {
        for (int j = i + 1; j < array.length; j++) {
            if (array[j] > array[i]) {
                temp = array[j];
                array[j] = array[i];
                array[i] = temp;
            }
        }
    }
    return array;
}

面向对象编程

面向对象：OOP

面向过程思想：现象思维

步骤清晰简单，第一步做什么，第二步做什么…
面向过程适合处理一些比较简单的问题

面向对象思想

物以类聚，分类的思维模式，首先思考解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

对于描述复杂的事物，为了从宏观上把握、从真提升合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理

什么是面向对象：

面向对象编程（Object-Oriented Programming，OOP）

面向对象编程的本质就是：以类的方式组织代码，以对象形式（封装）数据

抽象

三大特性

封装
继承
多态

从认识角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象。类似对象的模板

构造器：

使用new关键字，本质是在调用构造器
构造器用来初始化值
一旦定义了有参构造，无参构造就必须显示定义

特点：

和类名相同
没有返回值

封装：

该露的露，该藏的藏
- 我们程序设计需要追求==“高内聚，低耦合”==。高内聚就是内的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅仅暴露少量的方法给外部使用
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏
记住这句：属性私有，get/set

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
增加系统可维护性

继承：

继承的本质是对某一类的抽象，从而实现对现实世界更好的建模
extends的意思是扩展。字类是父类的扩展
java中只有单继承，没有多继承
子类继承了父类，就会拥有父类的所有的公共方法

super注意点：

super调用父类的构造方法，必须在构造方法第一个
super必须只能出现的子类的方法或者构造方法中
super和this不能同时出现在构造方法中

VS this：

代表的对象不同
- this：代表本身调用的这个对象
- super：代表父类对象
前提：
- this：没有继承也可以使用
- super：支了个哉继承条件下才能使用
构造方法：
- this()：本类的构造
- super()：父类的构造

方法的重写：需要有继承关系，子类重写父类的方法

重写都是方法的重写，与参数无关

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大：public>protected>default>private
抛出的异常：可以被缩小，不能扩大

之类的方法和父类的方法必须一致，但方法体不同

为什么要重写：

父类的功能，之内不一定需要，或者不一定满足

多态

注意事项：

多态是方法的多态，属性没有多态
父类和子类，有联系
存在的条件：继承关系，方法需要重写，父类的引用指向子类的对象
1. static方法，属于类，不能重写
2. finnal常量
3. privite方法

public class Person {
    public void run() {
        System.out.println("Person");
    }
}

class Student extends Person{
    public void run() {
        System.out.println("Student");
    }
    public void go() {
        System.out.println("go");
    }
}


// 子类能调用的方法，都是自己的或者继承父类的
Student s1 = new Student();
//父类，可以指向子类，但是不能调用子类的方法
Person s2 = new Student();

s1.run();
//子类重写了父类的方法，执行子类的方法。前提是子类重写父类的方法
s2.run();

//如果父类没有run()方法，则需要强制转换
((Student)s2).go();

输出结果：
Student
Student
go

# 对象能执行哪些方法，要看左边的类型，与右边关系不大

public class Person {
    public static void run() {
        System.out.println("Person");
    }
}

class Student extends Person{
    public static void run() {
        System.out.println("Student");
    }
    public void go() {
        System.out.println("go");
    }
}

Student s1 = new Student();
Person s2 = new Student();

//如果方法为静态方法，则根据左边类型的方法输出
s1.run();
s2.run();
((Student)s2).go();

输出结果为：
Student
Person
go

多态体现为：父类引用指向子类对象

注意：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法

多态成员特点：

多态成员变量：编译运行看左边
多态成员方法：编译看左边，运行看右边

instanceof

x instanceof y : 看x与y是否存在父子类关系

static

静态方法和属性，在类创建的时候已经被加载！

可以直接被类名访问

非静态方法可以直接访问静态方法，静态方法可以调用静态方法，静态方法不能调用非静态方法

执行顺序：

public class StaticTest {

    {
        System.out.println("匿名代码块");
    }

    static {
        System.out.println("静态代码款");
    }

    public StaticTest() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        StaticTest test = new StaticTest();
    }
}

结果：
静态代码款
匿名代码块
构造方法

静态代码块只执行一次：

public class StaticTest {

    {
        System.out.println("匿名代码块");
    }

    static {
        System.out.println("静态代码款");
    }

    public StaticTest() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        StaticTest test = new StaticTest();
        System.out.println("===========");
        StaticTest test1 = new StaticTest();
    }
}

静态代码款
匿名代码块
构造方法
===========
匿名代码块
构造方法