JAVA基础学习

向光光同学

已于 2022-09-28 22:36:59 修改

阅读量180

点赞数

分类专栏： JAVA 文章标签： java 学习 jvm

于 2022-09-28 22:35:41 首次发布

本文链接：https://blog.csdn.net/Xg_316167164/article/details/127098351

版权

JAVA 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

快捷方式

psvm 回车- >

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

    sout  回车 ->    System.out.println(); //这个是单行的
	这个不知道快捷键是什么	System.out.print(i+" ");

ctrl + D 复制当前行到下一行
ctrl + h 查看继承结构
alt + insert
- 可以插入Getter and Setter 方法
- 也可以插入 override 重载的方法

JAVA 命令行运行

执行javac project.java 先编译
在执行 java project 在执行
主要要在src 路径运行，不能要在package里，否则会出现找不到 ”找不到或者无法加载主类“的情况

这里头有中文，所以加个字符编码设置 -encoding UTF-8

E:\JAVA_Project\test1\test_java\src>javac Applicant.java
.\test1\Son.java:8: 错误: 编码GBK的不可映射字符
        System.out.println("Son鐨勬棤鍙傛瀯閫?");
                                      ^
.\test1\Son.java:45: 错误: 编码GBK的不可映射字符
//            System.out.println("杈撳嚭鐨勫唴瀹逛负锛?"+str);
                                            ^
2 个错误

E:\JAVA_Project\test1\test_java\src>javac -encoding UTF-8 Applicant.java
E:\JAVA_Project\test1\test_java\src>java Applicant
Son的无参构造
Son class
Son的无参构造
Son class

变量命名规则

所有变量、方法、类名:见名知意
类成员变量:首字母小写和驼峰原则: monthSalary除了第一个单词以外，后面的单词首字
母大写lastname lastName
局部变量:首字母小写和驼峰原则
常量:大写字母和下划线: MAX_ VALUE
类名:首字母大写和驼峰原则: Man, GoodMan
方法名:首字母小写和驼峰原则: run(), runRun()

数组

C/C++ java python 获取数组长度的方法都不一样，真真无语

C/C++
- ```
int a[10] = {0};
int cnt = sizeof(a) / sizeof(a[0]);
printf("cnt = %d\n", cnt); //10 
```
- 用 sizeof 可以获得数据类型或变量在内存中所占的字节数。同样，用 sizeof 也可以获得整个数组在内存中所占的字节数。因为数组中每个元素的类型都是一样的，在内存中所占的字节数都是相同的，所以总的字节数除以一个元素所占的字节数就是数组的长度。

java

double[] nums = {1,2,2,3,4,525,3};
System.out.println(nums.length); //7

python
- ```
arr = [0,1,2,3,4,5]
print(len(arr)) #6
```

数组未解之谜


int[] array ;
int array[] ;
//这俩定义都是可以的， 第二个定义是C语言的设定，Java里面也引入了，是为了让C语言用户快速上手java

//使用new 操作符来创建数组
dataType[] array = new dataType[arraysize];
//这里的dataType 可以更换为相应的类型，int double float 等

Arrays 类

数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用,但API中提供了-个工具类Arrays供我们使
用，从而可以对数据对象进行一-些基本的操作。
查看JDK帮助文档
Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名进行调用，而”不
用"使用对象来调用(注意:是"不用”而不是“不能")
具有以下常用功能:
- 给数组赋值:通过fill方法。
- 对数组排序:通过sort方法按升序。
- 比较数组:通过equals方法比较数组中元素值是否相等。
- 查找数组元素:通过binarySearch方法能对排序好的数组进行二分查找法操作。
- 打印数组元素：toString
  - ```
  double[] nums = {1,2,2,3,4,525,3};
  //System.out.println(nums.toString()); 不能直接这样子写
  System.out.println(Arrays.toString(nums));
```

运算

double pow = Math.pow(2,3) // = 2*2*2=8
    
左移<<  右移 >>
2<<3 (2 的byte 0010 左移三维 右移同理)

JAVA帮助文档地址

https://docs.oracle.com/en/java/javase/18/docs/api

包机制

为了更好地组织类，JAVA提供了包机制，用于区别类名的命名空间.
包语句的语法格式为：
- package pkg1[.pkg2[.pkg3...]]；
  一般利用公司域名倒置作为包名；
  网站：www.baidu.com 包名 com.baidu.www
- 为了能够使用某一个包的成员，我们需要在程序中明确导入该包.使用“导入”语句可
  完成此功能
  import package[.package2...].classnema|* (*表示导入该包以下所有方法)

Scanner对象

工具类,获取用户的输入。java.util.Scanner是Java5的新特征，可以通过Scanner类来获取用户的输入。
基本语法:
Scanner s = new Scanner(System.in);
通过Scanner类的next()与nextLline() 方法获取输入的字符串,在读取前使用hasNext()与hasNextLine()判断是否还有输入的数据。
next():
1. 一定要读取到有效字符后才可以结束输入
2. 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3. 只有输入有效字符后才将其后面输入的空自作为分隔符或者结束符。
4. next() 不能得到带有空格的字符串。
nextLine(): .
1. 以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符。
2. 可以获得空白格。

package test1;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        if (scanner.hasNextLine()) { //scanner.hasNext()
            String str = scanner.nextLine(); // scanner.next()
            System.out.println("输出的内容为："+str);
        }
		scanner.close(); // 要记得关闭，要不然浪费内存
    }

必写两句话

Scanner scanner = new Scanner(System.in);
System.out.println("输出的内容为："+str);

增强for循环

这个在python里面也有

int[] numbers = {10,20,30,40,50};
for(int x :numbers){
	System.out.println(x);
}

关于goto关键字（不建议使用）

goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的- -个保留字，但并未在语言中得到正式使用; Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子–带标签的break和continue。
“标签” 是指后面跟一个冒号的标识符，例如: label:
对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

outer 在这里就是一个标签等进行到continue 的时候就会跳到outer处

outer:for (int i=101;i<150;i++){
            for (int j=2;j<i/2;j++){
                if (i%j==0){
                    continue outer;
                }
            }
            System.out.print(i+" ");
        }

JAVADOC生成文档

javadoc命令是用来生成自己API文档的
参数信息

@author作者名
@iversion 版本号
@since 指明需要最早使用的jdk版本
@param参数名
@return返回值情况
@throws异常抛出情况

javadoc -encoding UTF-8 -charset UTF-8 Test.java -encoding UTF-8 -charset UTF-8都是为了保证文档中的中文不乱码 主要能用的是index.html文件


E:\JAVA_Project\test1\test_java\src\test1>javadoc -encoding UTF-8 -charset UTF-8 Test.java
正在加载源文件Test.java...
正在构造 Javadoc 信息...
标准 Doclet 版本 1.8.0_341
正在构建所有程序包和类的树...
正在生成.\test1\Test.html...
正在生成.\test1\package-frame.html...
正在生成.\test1\package-summary.html...
正在生成.\test1\package-tree.html...
正在生成.\constant-values.html...
正在构建所有程序包和类的索引...
正在生成.\overview-tree.html...
正在生成.\index-all.html...
正在生成.\deprecated-list.html...
正在构建所有类的索引...
正在生成.\allclasses-frame.html...
正在生成.\allclasses-noframe.html...
正在生成.\index.html...
正在生成.\help-doc.html...

方法

修饰符public (private、protected) 和static 两个前后位置摆放没有关系。但习惯还是public在前面

public static int max(int x1,int x2){
//修饰符 修饰符 返回值 方法名 (参数类型 参数名)  
        return x1>x2?x1:x2;
    }

方法的重载（和重写区别很大）

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

JAVA 在方法调用中都是“值传递”

方法的重载的规则:

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

实现理论:

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对
应的方法，如果匹配失败,则编译器报错。

可变参数

JDK 1.5开始, Java支持传递同类型的可变参数给-个方法。
在方法声明中，在指定参数类型后加一一个省略号(…)。
一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它
之前声明。
**个人感觉这样子可变参数，在方法体内就是一个数组了 **

public static void printMax(double... numbers){
        if (numbers.length ==0){
            System.out.println("No argument passed");
        }
        
        double result = numbers[0];
        
        for(int i=1 ;i<numbers.length;i++){
            if(numbers[i]>result){
                result= numbers[i];
            }
        }
        System.out.println("the max value is "+ result);
    }

对可变参数方法传入一个数组是可以的，两个数组就会报错。

传入多个参数，是不会报错的。

double[] nums = {1,2,2,3,4,525,3};
double[] nums1 = {2,3,3,24};
printMax(nums);  
//printMax(nums,nums1); 这样子是会报错的。
double x1= 2;
double x2 =3;
double x3 =4;
printMax(x1,x2,x3); //不会报错，也是可变参数的好处

面向对象编程(Object-Oriented Programming, 00P)

定义

面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。
抽象 （确实蛮抽象的，讲完也没听懂）
三大特性: （感觉C++里面也有这三大特性啊，是记错了吗，#TODO之后复习C++的时候要再看看C++是什么特性）
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。

封装

个人觉得封装就是public和private的区别，把属性封装在类内，要对相关属性进行操作就要通过类内公开的public的方法操作，不能直接操作属性，这也是一方面安全性的体现。

// 快速插入底下几个方法的方式 alt+insert 选Getter and Setter 
public class Person {
    private String name;
    private int age ;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

继承

在JAVA中，所有的类，都默认直接或者间接继承Object

// 就不需要专门写extend objec 了， 已经时默认的。
public class Person /*extends Object */ {
    
}

ctrl+h 可以看继承解构

在这里插入图片描述

子类继承父类，就拥有父类的全部public方法

不能说是全部方法，但是父类中private的方法是无法继承和使用的，但protected 的属性和方法还是可以继承和使用的。

public class Father {
    public void print(){
        System.out.println("Father Class ");
    }
    private void fatherPrivate(){
        System.out.println("fatherPrivate");
    }
}

如果要用父类的方法，可以用super这个关键字。

在这里对方法进行的是”重写“，不是重载。重写都是方法的重写，与属性无关

public class Son extends Father{ 
    @Override  //有功能的注释符 ，提示是 重写的方法
    public void print(){
        System.out.println("Son class");
    }
    public void test(){
        this.print();
        super.print(); // 这里就是调用的父类的print
    }
}

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

 -  子类的方法和父类必须一致（参数列表等），方法体不同
 -  方法名必须相同
 -  参数列表必须相同
 -  修饰符，范围可以扩大但不能缩小， public >protected > Default>private 
 -  **抛出异常的范围：可以被缩小，但不能扩大，ClassNotException --> Exception(大)**

this 和 super的使用区别

当父类中有 有参构造时，最好在父类中也加上无参构造，否则子类在继承父类时无法用无参构造，比较麻烦还要必须写有参。
调用父类的构造器super必须要在子类构造器的第一行
super 必须只能出现在子类的方法或者构造方法中
super和this 不能同时调用构造方法
构造方法
- this 是本类的构造方法
- super是父类的构造方法 , 只能在继承条件下才可以使用。

 public class Son extends Father{
     public Son(){
         super(); // 调用父类的构造器必须要在子类构造器的第一行 // super 也可以不写，隐藏代码
     	 // this();  // this 此时和super不能同时出现 ，因为this 和super都必须出现在第一行
         System.out.println("Son的无参构造");
     }
 }

方法的调用只和左边定义的数据类型有关，和右边关系不大

public class Applicant {		
    public static void main(String[] args) {
        Son son = new Son();
        son.print(); // son
        
        //父类的引用指向了子类 ，可以指向子类，但是不能调用子类独有的方法
        Father father = new Son();
        father.print(); // father
       // father.fatherPrivate(); //error: 'fatherPrivate()' has private access in 'test1.Father'
    }
}
-------------------------
D:\Java\jdk1.8.0_341\bin\java.exe 
Son的无参构造 
Son class  //son.print(); 
Son的无参构造
Son class  //father.print();

多态

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多;
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
注意:多态是方法的多态，属性没有多态性。
instanceof

抽象类

abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法那公该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类,不能使用new关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

package test1;

//abstract 有抽象方法的类一定要声明为抽象类 
// 类 用extends：单继承（参照Action方法，Action方法不能再extend第二个class，（既不能有两个父类），但是一个父类可以有多个儿子，参照Action2方法）   （接口可以多继承）
// 一个JAVA类中可以有多个class类，但只能有一个public class类
public abstract class TestAction {
    //- 抽象类,不能使用new关键字来创建对象，它是用来让子类继承的。
    //- 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
    public abstract void doSomething();

    public static void main(String[] args) {
        new Action().doSomething();
        new Action2().doSomething();
    }

}


class Action extends TestAction {

    @Override
    public void doSomething() {
        System.out.println("It’s need to do something");
    }
}

class Action2 extends TestAction {

    @Override
    public void doSomething() {
        System.out.println("Action2 need to do something");
    }
}

接口

声明类的关键字是class，声明接口的关键字是interface
普通类:只有具体实现
抽象类:具体实现和规范(抽象方法)都有!
接口:只有规范!自己无法写方法_{专业的约束!约束和实现分离:面向接口编程}
接口就是规范，定义的是-组规则,体现了现实世界中“如果你…则必须能…"的思想。如果你是天使，则必须能飞。如果你是汽车,则必须能跑。如果你好人,则必须干掉坏人;如果你是坏人，则必须欺负好人。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
00的精髓,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象
能力的语言(比如c++、java, c#等) ,就是因为设计模式所研究的，实际，上就是如何合理的去抽象。

接口的作用

约束
定义一些方法，让不同的人实现~ 10—>1
public abstract
public static final // 不能被更改
接口不能被实例化_{，接口中没有构造方法}
implements可以实现多个接口
必须要重写接口中的方法~ .

package test1;


interface UserService{
    public void add(String name);
}

interface TimeService{
    public void timer();
    public void updateTime();
}

public class TestImplements implements UserService,TimeService{
    @Override
    public void add(String name) {
        
    }

    @Override
    public void timer() {
        
    }

    @Override
    public void updateTime() {
        
    }
}

public static final // 不能被更改

接口不能被实例化_{，接口中没有构造方法}
implements可以实现多个接口
必须要重写接口中的方法~ .

package test1;


interface UserService{
    public void add(String name);
}

interface TimeService{
    public void timer();
    public void updateTime();
}

public class TestImplements implements UserService,TimeService{
    @Override
    public void add(String name) {
        
    }

    @Override
    public void timer() {
        
    }

    @Override
    public void updateTime() {
        
    }
}

学习至：【【狂神说Java】Java零基础学习视频通俗易懂】

向光光同学

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础学习

面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。抽象（确实蛮抽象的，讲完也没听懂）三大特性: （感觉C++里面也有这三大特性啊，是记错了吗，#TODO之后复习C++的时候要再看看C++是什么特性）封装继承多态从认识论角度考虑是先有对象后有类。对象,是具体的事物。类,是抽象的,是对对象的抽象从代码运行角度考虑是先有类后有对象。类是对象的模板。。
复制链接

扫一扫