我的JavaSE知识总结 第一篇

最新推荐文章于 2022-09-13 19:46:15 发布
原创 最新推荐文章于 2022-09-13 19:46:15 发布 · 237 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文全面介绍了Java编程的基础知识，包括项目创建、数据类型、流程控制、类与对象、数组操作、异常处理等内容，适合Java初学者入门。

java基础

创建项目的方法

(1) 可以直接创建java项目

(2) 创建空项目 同时 new module-> 配置project structure，project项，选择jdk和相应版本

注释

  1. 单行注释 //
  2. 多行注释 /**/
  3. 文档注释
/**
 *@Description  HelloWorld
 *@Author Dylen_Liu
*/

数据类型

(1)最好完全避免浮点数比较，因为浮点数会舍入误差，造成比较出现问题

用BigDecimal 属性工具类

(2)字符本质海曙数字，用Unicode表 ，两个字节

从U0000 到 UFFFF

char c3 = '\u0061';

(3) 转义字符

\t \n \b

类型转换

(1) 低到高会自动转换，高到低要进行强制类型转换

(2) jdk7新特性， 数字直接可以用下划线分割 100_0000_000

Java基本类型占用的字节数：
1字节： byte , boolean
2字节： short , char
4字节： int , float
8字节： long , double
注：1字节(byte)=8位(bits)

附录：
1.编码与中文：
Unicode/GBK： 中文2字节
UTF-8： 中文通常3字节，在拓展B区之后的是4字节
综上，中文字符在编码中占用的字节数一般是2-4个字节。

变量作用域

  1. 类变量

  2. 实例变量

  3. 局部变量

public class Variable{
    static int allClicks = 0;  //类变量 有static
    String srt = "Hello World!"  //实例变量从属于对象
        
        public void method(){
        int i = 0;  //局部变量，卸载方法里面
    }
}

类变量随着类出现而出现，随着类消失而消失

可以不new对象就使用类变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mbE4GZNJ-1594963244472)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200712194152066.png)]

初识Math包

int num = Math.pow(2,3)

java.lang包下的类可以不用import直接使用

包机制

包本质就是文件夹

一般用公司域名倒置作为包名

com.baidu.www

类的上面要写它属于哪个包

package com.baidu.www;

package语句要写在文件最上面，在import之前

有时候我们需要导包

idea中报错可以用 alt+回车，会自动排错

别让包的名字重复

import con.Liu.base.*

*就是指把base类中的所有内容全部导入

idea中把这个去掉，展示包的层级结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-66E5F2yd-1594963244478)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200713091114432.png)]

JavaDoc生成文档

  • JavaDoc是用来生成自己的API文档的
/**
 *@author Dylen Liu
 *@version 1.0
*/

上述的加载类上面就是类的注释，加在方法上就是方法的注释

javadoc生成API帮助文档

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-c1RGZTul-1594963244488)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200712200953110.png)]

java流程控制

用户交互Scanner

java.util.Scanner 是java5出来的新特性，用来获取用户输入

通过Scanner类的next() 和 nextLine() 方法来获取输入的字符串，在读取前我们一般需要使用hasNext() 与 hasNextLine() 来判断是否还有输入的数据

基本语法：

Scanner s = new Scanner(System.in);

next()

  • next()不能得到带有空格的字符

nextLine()

  • 以Enter为结束符，也就是nextLine() 方法返回的是输入回车之前的内容
  • 可以获得空白
package com.Dylen.Scanner;

import java.util.Scanner;

public class Demon1 {
    public static void main(String[] args) {
        //创建一个Scanner对象用来接受键盘输入数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方法来获取输入");
        //判断scanner接下来还有没有输入，有的话就输出
        if(scanner.hasNext()){
            String str = scanner.next(); //接受next()来传给str
            System.out.println("输入内容是" + str);
        }

        //属于IO流的类用完就要关闭，否则会一直占用资源
        scanner.close();
    }
}

除此以外还有nextInt(), nextFloat(), hasNextInt(), hasNextFloat()，nextDouble() , hasNextDouble()

小例子，计算数字总和

package com.Dylen;

import java.util.Scanner;

public class Demon2 {
    public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);

       double sum = 0.0;
       int count = 0;

        System.out.println("请输入几个数字，我们将计算它们的平均数: ");
       while(scanner.hasNextDouble()){
           double i = scanner.nextDouble();
           sum = sum + i;
           count ++;
       }

        System.out.println("这些数字的总和是 "+ sum);
        System.out.println("这是数字的平均数是 "+sum/count);

        scanner.close();
    }
}

选择结构

  • if语句
  • switch语句
String s = scanner.nextLine();
//equals用来判断字符串是否相等
if(s.equals("Hello")){
    System.out.println(s)''
}
scanner.close();

switch语句中的value(case后面的那个值)可以是byte、short、int、或者char

jdk7以后可以是String

idea可以反编译，只要把class文件放到java文件当中，再在idea中打开就行

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FrXXhBCq-1594963244502)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200713100528931.png)]

循环结构

  • while循环
  • for循环
  • do while循环

for循环小例子，打印1到999能被5整除的数，没行打印三个

package com.Dylen.struct;

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

        for(int i = 0; i< 1000;i++){
            if(i % 5 ==0){
                System.out.print(i+"\t");
            }
            if(i %(5*3) ==0){
                System.out.println();
            }
        }
    }
}

for循环练习：打印九九乘法表

package com.Dylen.struct;

public class ForDemo2 {
    public static void main(String[] args) {
        for(int i =1;i <10;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j + "*" +i+"="+ j*i+ "\t");
            }
            System.out.println();
        }
    }
}

增强for语句

java5引入，主要作用于数组或者集合对象

int[] nums  ={11,22,33,44,55};

for(int x:nums){
    System.out.println(x);
}

Break和 Continue语句

break用来终止循环，也可以用在switch语句中

continue用于终止某次循环

循环结构综合练习

打印三角形：

package com.Dylen.struct;
/*
    *
   ***
  *****
 *******
*********
 */
public class TestDemo {
    public static void main(String[] args) {
        for(int i=1;i <=5 ;i++){
            for(int j =5; j>=i ;j--){
                System.out.print(" ");
            }

            for(int j=1; j<=i;j++){
                System.out.print("*");
            }

            for(int j = 1; j<i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

java方法

方法重载

在同一个类中，函数明相同，参数不同

规则

  • 方法名称必须相同
  • 参数列表必须不同(个数不同，类型不同，参数排列顺序不同)
  • 方法的返回类型可以相同可以不同
  • 仅仅返回类型不同不足以成为方法重载

命令行传参

  • 有时候希望运行一个程序的时候再给它传递消息，这要靠传递命令行蚕食来实现

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Jjv8rQxG-1594963244510)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200714105551920.png)]

在java程序所在目录下进行javac编译

在src目录下用java指令进行运行， java com.Dylen.methond.Demon this is DylenLiu

java运行时要把完整的包全部打出来，这样后面的输入就会存在args[] 数组里面了

可变参数

  • JDK 1.5 开始，java支持传递同类型的可变参数给一个方法
  • 在方法声明中，在指定参数类型后面加上一个省略号(…)
  • 一个方法中只能指定一个可变蚕食，它必须时方法的最后一个参数，任何普通蚕食必须在它之前声明
package com.Dylen.method;

public class Demon2 {
    public static void main(String[] args) {
        Demon2 d2  = new Demon2();
        d2.test(1,2,3,4,5,6);
    }

    public void test(int... i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
    }
}

可变长参数本质上就是数组

递归

递归就是A方法调用A方法(自己调用自己)

  • 递归结构包含两个部分
    1. 递归头:什么是狗不调用自身方法，如果没有头就会陷入死循环
    2. 递归体:什么时候需要调用自身方法。
public class Demon3 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }

    public static int f(int n){
        if(n == 1)
            return 1;
        else{
            return n*f(n-1);
        }
    }
}

数组

数组创建

int[] nums; 声明一个数组

nums = new int[5]; java使用new来创建数组

nums.length 用来获取数组长度

一般直接用

int[] nums = new int[5];

这种形式来创建数组

三种初始化以及内存分析

//静态初始化 声明加赋值
int[] ={10,20,30,50};

//动态初始化，有默认初始值
int[] a = new int[5];

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZxaNcu1L-1594963244515)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200714134844458.png)]

数组特点

数组变量属于引用类型，数组可以看成对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，java中的对象是在堆中的，云此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的

数组使用

  • for循环遍历
  public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
		//普通for循环
        for(int i = 0;i < arrays.length; i++)
            System.out.println(arrays[i]);
		//for each循环
        for (int array : arrays) {
            System.out.println(array);
        }
    }
  • 数组作为参数传入，并且把数组作为返回值
//返回一个新的数组，值与传入数组相反
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];

        for(int i = 0, j=result.length-1; i<arrays.length;i++, j--){
            result[j] = arrays[i];
        }
        return result;
    }

多维数组

int[][] arr = {{1,2},{2,3},{3,4},{4,5}};
int[][] res = new int[4][5];

Arrays类

  • Arrays中的方法都是static修饰的静态方法，在使用的时候可以直接调用，不用使用对象来调用(当然也可以用对象来调用)
package com.Dylen.Array;

import java.util.Arrays;

public class ArrayDemon2 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,89,45,750};

        System.out.println(a);
        System.out.println(Arrays.toString(a));

        Arrays.sort(a);
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

冒泡排序是最有名的排序算法之一

总共有八大排序

  • 当一个数组中大多数元素都位0，或者为同一值得数组时，可以使用稀疏数组来保存该值
  • 稀疏数组得处理方式是
    1. 记录数组一共有几行几列，有多少不同值
    2. 把具有不用值得元素和行列及值记录在一个小规模得数组中，从而缩小程序规模

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dvAULrIW-1594963244520)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200715110537162.png)]

稀疏数组第1列存行数[i][0]，第2列存列数[i][1]，第三列存值[i][2]

第一行存数组信息，行数、列数、有效值个数

package com.Dylen.Array;

public class ArrayDemon3 {
    public static void main(String[] args) {
        //创建一个11行11列的棋盘，0表示没有棋子，1表示黑棋，2表示白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        System.out.println("打印原始数组");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        //转换为系数数组保存
        //获取有效值的个数
        int sum = 0;
        for(int i =0;i<11;i++){
            for(int j =0;j <11; j++ ){
                if(array1[i][j] != 0)
                    sum++;
            }
        }
        System.out.println("有效值个数为:"+sum);

        //2.创建一个稀疏数组
        //三列是因为有效数组只有行、列、值 这三列
        int[][] array2 = new int[sum+1][3];
        //数组11行，11列，有sum个有效个数
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二位数组，将非零的值，存放系数数组中
        int count = 0;
        for(int i = 0; i < array1.length; i++){
            for(int j = 0; j < array1.length; j++){
                if(array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

        System.out.println("稀疏数组");

        for(int i = 0; i < array2.length; i++){
            System.out.println(array2[i][0] + "\t"
                        +array2[i][1]+"\t"
                        +array2[i][2]+"\t" );
        }

        System.out.println("还原数组");
        System.out.println("---------------------------");

        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原它的值
        for(int i = 1; i < array2.length; i++){
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        System.out.println("打印原始数组");

        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
    }
}

面向对象编程

三大特性

  • 封装
  • 继承
  • 多态

在方法中，若一个方法被static修饰那么外部类中可以直接用该方法所在类名来调用该方法

public class Student{
    public static void say(){
        
    }
}

public class Demon{
    public static void main(String[] args){
        Student.say();
    }
}

没有static关键字，要创建实例来调用

static方法和类一起加载的

没static的方法在创建实例之后才存在

值传递和引用传递

值传递例子

public class Demon4{
    public static void main(String[] args){
        int a = 1;
        
        System.out.println(a);
        
        Demon4.change(a);
        
        System.out.println(a);
    }
    
    public static void change(int a){
        a = 10;
    }
}

a的值不会改变

引用传递

public class Demon4{
    public static void main(String[] args){
        Person p = new Person();
        
        System.out.println(p.name);
        
        Demon4.change(p.name);
        
        System.out.println(p.name);
    }
    
    public static void change(Person p){
       p.name = "DylenLiu";
    }
}

public class Person{
	String name;
}

p.name的值会改变

类与对象的关系

  • 类是一种抽象的数据类型，对象是一种实例

类里面只有属性和方法

面向对象本质：以类的方式组织代码，以对象的方式封装数据

构造函数

作用

  1. 用new关键字必须要有构造器，new本身是在调用构造函数
  2. 实例化初始值

idea中： alt+insert 来自动生成构造函数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cvMPNYe7-1594963244524)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200716110721252.png)]

封装

程序设计要求：高内聚，低耦合

高内聚就是类的内部数据操作细节自己完成，不允许外部干涉

低耦合:就暴露少量方法给外部使用

indea： alt +insert 自动生成get、set方法

继承(extends)

父类私有(private) 的东西是无法继承的

idea中ctrl + h 打开继承关系树

java中所有类都默认继承Object类

单继承:

​ 一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子

super关键字

当父类中的元素是protected类型的时候(protected 子类可以调用)

用super关键字可以调用父类中的内容

image-20200716115757855

隐藏的代码是super();

调用父类构造方法一定要在子类构造方法第一行

父类中写了有参构造就没有无参构造了

默认的super(); 就会报错

super注意点:

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

Vs this:

  • 代表对象不同
    • this: 本身调用这个对象
    • super：代表父类对象的应用

this没有继承也能使用

super:只有在继承条件中才可以使用

构造方法:

​ this(): 本类的构造

​ super(): 父类的构造

方法的重写

重写指的都是方法的重写和属性无关

public class A extends B{
    public static void test(){
        
    }
}

//Test类中的main方法中
A a = new A();

B b = new A();	//父类引用指向子类

@Override //注解，有功能的注释，这个注解意思就是方法重写

方法重写只和非静态方法有关

和static方法无关

重写方法修饰符只能是public，不能是private

重写：

  1. 需要有继承关系并且子类重写父类的方法
  2. 方法名必须相同
  3. 参数列表必须相同
  4. 修饰符：范围可以扩大，不能缩小：public > protected >default>private
  5. 抛出的异常：范围可以被缩小，但是不能扩大

就是子类和父类方法要一致，就是方法体不同

为什么要重写：

  1. 父类的功能，子类不一定需要，或者不一定满足

    Alt + Insert : @Override

多态

public class Student extends Person{
    
}

//一个对象的实际类型是确定的
new Student();
new Person();

//可是指向的引用类型就不确定了,父类的引用可以指向子类
//不能调用子类独有的方法 
Person p = new Student();
//(重要)上面的代码，要是子类中有的方法，父类中没有，p就不能调用该方法

动态编译：类型只有在运行时才知道，使得可扩展性更强

对象执行什么方法主要看左边类型，和右边关系不大

多态注意事项：

  1. 多态是方法的多态，和属性无关
  2. 父类和子类之间， 类型转换异常 ClassCastException
  3. 存在条件：继承关系，方法需要重写 父类引用指向子类对象

Father f = new Son();

有些方法不能重写

  1. static方法，属于类，不属于实例
  2. final 常量：
  3. private方法

核心:同一种方法可以根据发送对象的不同采用多种不同的行为方式

instanceof和类型转换

instanceof可以判断一个类是什么类型(主要用于判断是否有父子关系)

Object object = new Person();

System.out.println(object instanceof Person);
    
System.out.println(x instanceof Y); //编译是否通过主要看x和Y是否有父子关系
//看左边，若和instanceof右边有关系那么就通过，否则就报错
//看右边(x指向的类型)，若和instanceof右边有关系那么就true、否则就false

类型转换，低转高可以直接转，高转低要进行强制类型转换

//Person类中有go方法
//Student类中有run方法
public static void main(String[] args){
    Perosn p = new Student();	//Student型转Perosn 低转高直接转
    
    p.run();					//这个会报错，因为Person里面没有run()方法
    ((Student)p).run();			//需要强制类型转换
    
}

Student student = new Student();

Person p2 = student;	//自动转换，因为是低转高
//但是p2就不能用run方法
//子类转父类可能会丢失一些方法

父类引用指向子类

Person p = new Student();

通过该引用调用子类内部重写父类的方法，或者父类中已经有的方法

如果想用子类中独有的方法需要进行强制类型转换

(Student§).run();

static关键字

非静态方法可以直接调用静态方法

public class Demon{
    //匿名代码块{
        
    }

	//静态代码块
	static{
        
    }

	//构造函数public Demon(){
        
    }

	public static void main(String[] args){
        new Demon();
    }
}

上述代码会先执行静态代码块->匿名代码块->构造函数

静态代码块随着类的加载而加载

匿名代码块和构造函数都是随着对象的创建而加载

import static java.lang.Math.random; 
//这是静态导入包，可以直接使用
random();

由final修饰的类不能别继承

public final class Person{
    
}

抽象类

//这是抽象类，里面的方法叫抽象 方法
public abstract class Action{
    public abstract void run();
    
}

//如果抽象类被继承，那么该子类必须要重写抽象类中的抽象方法，除非子类也是抽象类
//抽象类只能单继承，但是借口可以多继承
public class A extends Action{
    
}

抽象类不能new，只能靠子类来new，主要起到约束作用

类中有抽象方法，那么该类一定要是抽象类，但是抽象类中也能有普通方法

以举例的方式说到如何区分抽象类和接口，这里我们从Java语法谈起，使我们更加了解这两者的内在区别。它们的语法区别：
1）接口不能有构造方法，抽象类可以有。
2）接口不能有方法体，抽象类可以有。
3）接口不能有静态方法，抽象类可以有。
4）在接口中凡是变量必须是public static final，而在抽象类中没有要求。
————————————————
版权声明：本文为优快云博主「lllllzllll」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/qq_40728375/article/details/79890223

接口

  • 接口就是一种规范，定义了一组规则，就是显示生活中的"你如果是…就一定得会…"思想
  • 接口本质就是一种契约
public interface UserService{
    void run();		//默认是public abstract
}

public interface ActService{
    
}


public class A implements UserService,ActService{
    
}

总结

  1. 接口中的所有方法都是public abstract
  2. 接口中的所有属性都是public static final
  3. 可以implements 多个接口，多继承
  4. 接口中没有构造函数
  5. 接口是一种规范，在设计模式中广泛使用过

内部类

在一个类的内部再定义一个类

public class Outer{
    private int id = 0;
    
    public class Inner{
        //内部类可以获取外部类的私有变量
        public int getID(){
			return id;
        }
    }
}

public static void main(String[] args){
    Outer outer = new Outer();
    //如何声明内部类
   Outer.Inner inner = outer.new Inner();
}

一个.java文件只能有一个public class类，但是可以有多个class文件

public class Outer{
    public void method(){
        //局部内部类
        class A{

        }
    }
}

异常

异常的分类：

  1. 检查性异常：用户错误或问题引起的，程序员无法预知
  2. 运行时异常：可以在编译时被忽略，但是可能被程序员忽略的异常
  3. 错误： 例如stackoverflow等

Java把异常当作对象来处理，并且定义了一个基类， java.lang.Throwable作为所有异常的超类

Java API中定义了很多异常类，这些异常类分为两大类，错误Error，和异常Exception

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a4ASSFWX-1594963244528)(C:\Users\20886\AppData\Roaming\Typora\typora-user-images\image-20200717121720641.png)]

Error：

  • Error由JVM生成并抛出，大多数错误与代码编写者无关
  • Java虚拟机运行错误(Virtual MachineError),这些异常出现时，jvm一般选择线程终止
  • 虚拟及试图运行程序时出现类错误，链接错误

Exception：

  • 这个类里面有一个很重要的子类RuntimeException

这里面的异常通常由程序逻辑错误引起，程序员的问题，可以避免

抛出以及抓取异常

package com.Dylen.Exception;

public class Demon1 {
    public static void main(String[] args) {
        int a =1;
        int b =0;

        try{//代码监控区域
            System.out.println(a/b);
        }catch(ArithmeticException e){//捕获异常 catch(想要捕获的异常类型)
            System.out.println("程序出现异常，b不能为0");
            e.printStackTrace();//打印错误的栈信息
        }finally{//处理善后工作，一定会执行
            System.out.println("finally");
        }
    //catch可以写多个格式和else一样，但是最大范围的只能写在最下面


    }
    //方法上抛出异常，需要被try catch捕获
    /*
    *   try{
    *          new Demon1.test();
    *       }catch(){
    *   
    * }
    * */
    public void test(int a,int b)throws ArithmeticException{
        if(b == 0)
            throw new ArithmeticException(); //主动抛出异常，主要在方法中使用
    }
}

异常五个关键字：try catch finally throw throws

快捷键：选中要监控的代码，ctrl + alt + t 就可以选择了

自定义异常

写一个类去继承Exception类

狂神javase总结.png
07-03
狂神javase总结
Java学习总结.png
04-03
JAVASE 基础知识总结
JavaSE回顾总结（狂神说java）.xmind
05-11
javaSE回顾总结，学习笔记，查漏补缺。 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点 。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等.
idea总结，超详细（png图片）
05-25
一、常用配置1）、配置JDK 2）、配置maven 3）、编码配置 4）、容器配置 5）、配置git 初次创建项目的情况 已有项目在远程仓库的情况 二、建议修改 三、主题 1）、主题 2）、背景 3）、字体 4）、显示 四、快捷键 1）、搜索 2）、操作 四、插件 1）、Free Mybatis plugin 2）、Maven Helper 3）、FindBugs-IDEA
Spring
m0_51915183的博客
04-16 724
spring随笔
2023年JAVASE知识点总结java第一阶段.doc
最新发布
08-05
2023年JavaSE知识点总结涵盖了Java的核心基础和编程基础，为学习者提供了一个全面的概览。Java SE（Standard Edition）是Java平台的核心，是学习Java技术的基础，其他平台如Java EE和Java ME都是建立在Java SE之上的...
JavaSE知识点总结.doc
06-10
JavaSE知识点总结 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）于1995年发布。它以其“一次编写，到处运行”的特性而闻名，这意味着编写好的Java程序可以在任何支持Java的平台...
javaSE基础知识总结1
08-08
【JavaSE基础知识总结1】 Java 是一种广泛使用的高级编程语言，具有面向对象、跨平台、安全性强等特点。本文主要概述了Java的基础知识，包括运行Java程序的方法、语言基础、标识符与关键字、数据类型以及逻辑控制和...
javase基础知识总结
06-08
理解JDK、JRE和JVM的关系是学习Java的第一步。安装JDK并设置`path`和`classpath`环境变量是确保Java程序能够正确执行的关键。 接着，我们进入编程基础。关键字是Java语言预定义的、有特殊含义的词，如`public`、`...
java——类和对象
asdfg2047的博客
07-28 440
/方法有返回值，返回值是什么类型，就写什么类型，返回值类型可以是基本数据类型，也可以是引用数据类型，方法有返回值，需要使用return将结果返回。System.out.println("你的姓名是"+name+"，年龄是"+age);*调用一个有返回值的方法，对于返回的结果，你可以直接输出，也可以使用返回类型的变量去接收返回值。*4）方法的参数列表，可以有可以没有，有参数的时候，可以有一个，也可以有多个。//方法根据是否有返回值分为无返回值的方法和有返回值的方法。...
12.类和对象
baaa111的博客
09-13 336
带你了解什么是类，什么是对象。万事万物皆对象！
Java内部类和异常类/程序设计语言的基本概念
想带狗熊去吹风
06-20 865
CET4P211 weaken dumb landlord horrible intense scope recovery refusal edition glove handwriting educate speculate mechanism
JAVA成员内部类声明相关方法理解
Szero
04-22 781
JAVA成员内部类声明相关方法理解
内部类_简单应用
学无止境，Fighting！
04-20 802
内部类：在一个类中定义另一个类，类中的类称为内部类（相对于外嵌类）。基本属性：    外嵌类的属性在内部类中有效，内部类可以在方法中调用外嵌类的方法；    外嵌类的类体可以用内部类声明对象作为外嵌类的属性;    除外嵌类，其他类不可以用内部类声明对象。以下为简单的内部类应用的例子：RedCowForm.javapublic class RedCowForm { public static S...
Java零基础系列教程06初识类和对象
douyh的专栏
10-01 487
配套视频教程 本文B站配套视频教程 万物皆对象 分类是人们认识世界的一个很自然的过程，在日常生活中会不自觉地进行分类 身边的对象 顾客 姓名—张浩 年龄—20 体重—60kg 操作： 购买商品 收银员 员工号—10001 姓名—李明 部门—财务部 操作： 收款 打印账单 对象的特征——属性 属性——对象具有的各种特征 每个对象的每个属性都拥有特定值 例如：张浩和李明的年龄、姓名不一样 对象的特征——方法（操作，行为） 方法——对象执行的操作（通常会改变属性的值） 对象：用来描述客观事物的一个
Java中的内部类（成员内部类、静态内部类、局部内部类、匿名内部类）
weixin_34128839的博客
04-27 197
Java中的内部类（成员内部类、静态内部类、局部内部类、匿名内部类） 神话丿小王子的博客主页 　　我们先看这样一段话：人是由大脑、肢体、器官等身体结果组成。而组成我们人体的心脏它也有自己的属性和行为（血液、跳动），显然，此处不能单方面用属性或者方法表示一个心脏了，而需要一个类，但是这个类要依赖于人这个类存在（因为心脏不能脱离人体而存活，当然不考虑现今社会的发达科技，只从正常情况下来说），所心脏...
2023年JavaSE核心知识点全面总结
资源摘要信息:2023年JAVASE知识点总结java第一阶段.doc是一份系统全面的Java SE（Standard Edition）学习资料，主要面向Java初学者和正在学习Java第一阶段的开发人员。该文档涵盖了Java语言核心基础知识体系，是进入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值