javase总结

JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程序运行的所需环境。
JDK(Java Development Kit):Java开发工具包，提供给Java程序员使用，包含了JRE，同时还包含了编译器javac与自带的调试工具Jconsole、jstack等。

2.数据类型与运算符

1.变量和类型

变量：byte，short，int，long，float，double，char，boolean（共8种）

类型：引用类型（例如String类）和非引用类型（以上八种）

2.运算符

主要是算术运算符（+ - * /），关系运算符(> < == !=)和逻辑运算符(&& || !)。除此之外还有位运算符(& | ~ ^)，位移运算符(<< >> >>>)和条件运算符(?:)

运算符之间存在优先级关系，我们不必死记硬背，在有歧义时使用括号

3.程序逻辑控制

1.分支结构

if () {
}

if () {

} else {

}

if () {

} else if() {

}

2.循环结构

for循环

for(int i = 0;i<size;i++){

}

while循环

while(true) {

}

do-while循环

do {

} while()

4.方法的使用

1.方法的定义

修饰符+返回值类型+方法名+参数列表（形参）+方法体

public static final int add(int a,int b){
    return a+b;
}

2.方法的使用

返回值变量 = 方法（实参）；

int res = add(3,5);

3.方法的重载

方法的名字都叫 add. 但是有的 add 是计算 int 相加, 有的是 double 相加; 有的计算两个数字相加, 有的是计算三个数字相加。
同一个方法名字, 提供不同版本的实现, 称为方法重载

针对同一个类:
方法名相同
方法的参数不同(参数个数或者参数类型)
方法的返回值类型不影响重载.

4.方法的递归

一个方法在执行过程中调用自身, 就称为 "递归"。

利用递归求阶乘

public static void main(String[] args) {
  int n = 5;
  int ret = factor(n);
  System.out.println("ret = " + ret);
}
public static int factor(int n) {
  if (n == 1) {
    return 1;
 }
  return n * factor(n - 1); // factor 调用函数自身
}

5.数组的定义和使用

初始化数组

// 动态初始化
数据类型[] 数组名称 = new 数据类型 [] { 初始化数据 };
// 静态初始化
数据类型[] 数组名称 = { 初始化数据 };

数组静态初始化和动态初始化的区别_保弘历的博客-CSDN博客_静态初始化和动态初始化的区别

注意事项
1. 使用 arr.length 能够获取到数组的长度. . 这个操作为成员访问操作符. 后面在面向对象中会经常用到.
2. 使用 [ ] 按下标取数组元素. 需要注意, 下标从 0 开始计数
3. 使用 [ ] 操作既能读取数据, 也能修改数据.
4. 下标访问操作不能超出有效范围 [0, length - 1] , 如果超出有效范围, 会出现下标越界异常

fori遍历

int[] arr = {1, 2, 3};
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
// 执行结果
1
2
3

for-each遍历

int[] arr = {1, 2, 3};
for (int x : arr) {
System.out.println(x);
}
// 执行结果
1
2
3

数组转字符串

import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
// 执行结果
[1, 2, 3, 4, 5, 6]

数组拷贝

import java.util.Arrays
int[] arr = {1,2,3,4,5,6};
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));
// 拷贝某个范围.
int[] newArr = Arrays.copyOfRange(arr, 2, 4);
System.out.println("newArr2: " + Arrays.toString(newArr2));

注意事项: 相比于 newArr = arr 这样的赋值, copyOf 是将数组进行了深拷贝, 即又创建了一个数组对象, 拷贝原有
数组中的所有元素到新数组中. 因此, 修改原数组, 不会影响到新数组.

6.类和对象

类的概述

类就是一类对象的统称。对象就是这一类具体化的一个实例。
简单的例子：我们做月饼的模子就是一个类，而通过这个模子可以做出月饼，那么在这个例子当中，类就是那个模子，而月饼就是那个对象,所以月饼就是一个实体。一个模子可以实例化无数个对象。
总的来说：类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。
声明一个类就是创建一个新的数据类型，而类在 Java 中属于引用类型， Java 使用关键字 class 来声明类。

创建类的语法

// 创建类
class <class_name>{ 
  field;//成员属性
  method;//成员方法
}
// 实例化对象
<class_name> <对象名> = new <class_name>();

类的成员

类的成员可以包含以下：字段、方法、代码块、内部类和接口等。

在类中, 但是方法外部定义的变量. 这样的变量我们称为 "字段" 或 "属性" 或 "成员变量"(三种称呼都可以, 一般不会严格区分).

方法：构造方法和普通方法

static关键字

a) 修饰属性，Java静态属性和类相关, 和具体的实例无关. 换句话说, 同一个类的不同实例共用同一个静态属性.

b) 修饰方法
如果在任何方法上应用 static 关键字，此方法称为静态方法。
静态方法属于类，而不属于类的对象。
可以直接调用静态方法，而无需创建类的实例。
静态方法可以访问静态数据成员，并可以更改静态数据成员的值。

private实现封装（getter和setter方法）

private/ public 这两个关键字表示 "访问权限控制" .
被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用.
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用.
换句话说, 类的使用者根本不需要知道, 也不需要关注一个类都有哪些 private 的成员. 从而让类调用者以更低的成本来使用类。

构造方法

构造方法是一种特殊方法, 使用关键字new实例化新对象时会被自动调用, 用于完成初始化操作。

1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

class Person {
    private String name;//实例成员变量
    private int age;
    private String sex;
    //默认构造函数 构造对象
    public Person() {
        this.name = "caocao";
        this.age = 10;
        this.sex = "男";
    }
    //带有3个参数的构造函数
    public Person(String name,int age,String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class Main{
    public static void main(String[] args) {
        Person p1 = new Person();//调用不带参数的构造函数 如果程序没有提供会调用不带参数的构造函数
        p1.show();
        Person p2 = new Person("zhangfei",80,"男");//调用带有3个参数的构造函数
        p2.show();
    }
}
// 执行结果
name: caocao age: 10 sex: 男
name: zhangfei age: 80 sex: 男

this关键字

this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法。

class Person {
    private String name;//实例成员变量
    private int age;
    private String sex;
    //默认构造函数 构造对象
    public Person() {
    //this调用构造函数
        this("bit", 12, "man");//必须放在第一行进行显示
    }
    //这两个构造函数之间的关系为重载。
    public Person(String name,int age,String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show() {
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}
public class Main{
    public static void main(String[] args) {
        Person person = new Person();//调用不带参数的构造函数
        person.show();
    }
}
// 执行结果
name: bit age: 12 sex: man

代码块

使用 {} 定义的一段代码。
根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块：定义在方法内部的代码块（少见）

构造代码块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。（注意事项: 实例代码块优先于构造函数执行）

静态代码块：使用static定义的代码块。一般用于初始化静态成员属性。（静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。
静态代码块执行完毕后, 实例代码块（构造块）执行，再然后是构造函数执行。）

同步代码块

匿名对象

匿名只是表示没有名字的对象.
没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象.

7.时间复杂度和空间复杂度

算法效率

算法效率分析分为两种：第一种是时间效率，第二种是空间效率。时间效率被称为时间复杂度，而空间效率被称作空间复杂度。时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间，在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

8.面向对象编程

包

包 (package) 是组织类的一种方式.
使用包的主要目的是保证类的唯一性.

继承

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).
有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联.
例如, 设计一个类表示动物

// Animal.java
public class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
    }
// Cat.java
class Cat {
    public String name;
    public Cat(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
// Bird.java
class Bird {
    public String name;
    public Bird(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}

这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.
从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义).
此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果.
此时, Animal 这样被继承的类, 我们称为父类 , 基类或超类, 对于像 Cat 和 Bird 这样的类, 我们称为子类, 派生类和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果.

多态

多态是面向对象程序设计中比较难理解的部分. 我们会在后面的抽象类和接口中进一步体会多态的使用. 重点是多态带来的编码上的好处.
另一方面, 如果抛开 Java, 多态其实是一个更广泛的概念, 和 "继承" 这样的语法并没有必然的联系.
C++ 中的 "动态多态" 和 Java 的多态类似. 但是 C++ 还有一种 "静态多态"(模板), 就和继承体系没有关系了.
Python 中的多态体现的是 "鸭子类型", 也和继承体系没有关系.
Go 语言中没有 "继承" 这样的概念, 同样也能表示多态.
无论是哪种编程语言, 多态的核心都是让调用者不必关注对象的具体类型. 这是降低用户使用成本的一种重要方式.

接口

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含
静态常量.

抽象类

没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstract
method), 包含抽象方法的类我们称为抽象类(abstract class)

钢铁的面条

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
javase总结

1.开发环境的安装Java是一门半编译型、半解释型语言。先通过javac编译程序把源文件进行编译，编译后生成的.class文件是由字节码组成的平台无关、面向JVM的文件。最后启动java虚拟机来运行.class文件，此时JVM会将字节码转换成平台能够理解的形式来运行。JRE(Java Runtime Environment):Java运行时环境，包含了JVM，Java基础类库。是使用Java语言编写程序运行的所需环境。JDK(Java Development Kit):Java开发工具包，提供给J
复制链接

扫一扫