JAVASE 基础复习巩固

最新推荐文章于 2023-10-14 20:19:36 发布

夏枯无言

最新推荐文章于 2023-10-14 20:19:36 发布

阅读量3.9k

点赞数

分类专栏： javaSE 文章标签： java

本文链接：https://blog.csdn.net/pearl23544/article/details/112791938

版权

javaSE 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

JAVASE 基础复习巩固(1)

配置环境变量

出现错误：找不到或无法加载主类

//Demo2.java
package com.wang.method;

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

错误原因： java -version测试，显示JDK版本正常； JDK编译正常，那么JAVA_HOME配置正确。 package设置的和类路径的设置不匹配，执行器找不到类文件；

解决方法

删除第一行package语句，让编译文件处于当前文件夹
不去掉package语句，返回到src目录即执行时需要带包名java com.wang.method.Demo2

参考链接：

cmd命令行编译JAVA程序时出现“找不到或无法加载主类”

环境配置错误，cmd运行出现java不是内部或外部命令

数据类型扩展

整数二进制0b 八进制0 十六进制0x

浮点数 float double

最好完全避免使用浮点数计算

原因：浮点数在计算机中的表示个数有限，即离散，只要是离散的就存在舍入误差，即取得值为近似值而非精确值。

举例：

float f1=1.0;
float f2=1.0/10;
System.out.println(f1==f2);//false
f1=551230115632115;
f2=f1+1;
System.out.println(f1==f2);//true

涉及浮点数运算的解决方法：BigDecimal 数学工具类

银行业务都使用该工具

**字符类型转换为对应的ASCII码，**使用unicode ,可对所有语言，有2个字节，[0-65536）汉字也有对应的unicode码，即对应得到数字。

unicode 的表示形式 \u+十六进制，输出该unicode码表示的字符。

转义字符

\t ,\n，…

单行注释 // 多行注释 /* */ JavaDoc 文档注释

/**

@description 文档

@author wang

变量

Java是强类型语言，变量需要声明类型

变量命名规范

变量名易读易懂
类成员变量、局部变量、方法名：首字母小写驼峰原则 monthSalary
常量：全大写和下划线
类名：首字母大写，驼峰原则

变量的作用域：类变量、实例变量、局部变量

实例变量

在类之中，方法之外

public class Hello{
    int age ;//实例变量
    public void add(){
        Hello hello =new Hello();//新建对象
        system.out.println(hello.age);
    //此时尽管未给hello.age赋值，但默认输出0
    }  
}

boolean 类型默认false,基本数据类型默认0，其他默认为null

局部变量

定义在方法之中，只能在该方法中调用，必须进行初始化

public class Hello{
    int age ;//实例变量
    public void add(){
        int i;
        system.out.println(i);
        //此时报错
    }  
}

类变量

从属于类，随类出现，随类消失，与实例变量不同，实例变量是随对象出现随对象消失。

类对象的声明 **static type 变量名=value;**可直接调用

public class Hello{
    static int age =12;//实例变量
    public static void main (string[] args){
        system.out.println(age);
        //此时报错
    }  
}

常量

常量声明 final 常量名=value; 一般使用大写字符。

运算符

算数运算符：+、-、*、/、%、++、–

赋值：=

关系：>,<,==,!=,>=

逻辑运算：&&、||，！

位运算：&、|、~、^\

条件运算：？：

扩展赋值：+=、-=

不同类型的数据运算结果为最高类型，即升型

public class Hello{
    
    public static void main (string[] args){
        long a=123445;
        int b=2;c
        int c=a+b;//报错，a+b只能以long数据类型或更高类型存储
        system.out.println(c);
        //此时报错
    }  
}

包机制

一般使用公司域名倒序，每个java类中首行是包名。

使用其他包需要提前导入

import java.util.Date;
import java.util.math;
import java.util.*;//导入所有类

JavaDoc

用于生成自己的API文档,类和方法都可有。

public class Doc {
    /**
     * 
     * @author wang
     * @version 1.0
     * @since 1.8 
     */
    String name;
    //如下即为test方法的JavaDoc文档
    /**
     *
     * @param name
     * @return
     */
    public String test(String name){
        return name;
    }
}

用户交互scanner

java.util.Scanner工具包，通过Scanner类获取用户输入

      Scanner s=new Scanner(System.in);//创建对象接收键盘数据（字符串类型）
        //判断接受的字符串是否为空
        if(s.hasNext()){//输出第一个空格之前的内容
            String str=s.next();
            System.out.println(str);
        }
          if(s.hasNextLine()){
            String s1=s.nextLine();//以行的形式输出
            System.out.println(s1);
        }
        else{
            System.out.println("空");
        }
       s.close();//关闭节约资源
        //输入IO流的类如果不关闭会一直占用资源

Scanner对象next()方法

读取到有效字符才能结束输入，即如果换行前的输入为空，Scanner会一直等待输入。
有效字符之前的空格，会自动去掉。例如“ myname”如果输入则为“myname”。
不能得到带有空格字符串，即读取的停止字符为空格。

nextLine()方法

以换行为结束符，即该方法返回的是回车前的所有字符。
返回值中可存在空格字符。

//判断输入为整数或者其他数据类型
      Scanner s1=new Scanner(System.in);
        System.out.println("请输入整数：\n");
      if(s1.hasNextInt()){//判断读取是否为整数，其他数据类型类似，hasNextFloat()。
          int i=s1.nextInt();
          System.out.println(i);
      }

//输入多个数字，求总和和平均数。数字类型与字符串不同
public class Demo1 {
    public static void main(String[] args) {
        int sum=0;
        int count=0;
        System.out.println("请输入数字：");
        Scanner s=new Scanner(System.in);;
        while(s.hasNextInt()){
                sum+=s.nextInt();
                count++;
                //System.out.println(s.nextInt());
            }

        s.close();
        System.out.println("输入整数的总和："+sum+"输入整数的平均数："+sum/count);

    }
}

Java方法

命名规则：首字母小写，驼峰规则

方法设计的原则：方法实质是功能块，实现某个功能的语句块的集合，保持方法的原子性，一个方法只完成一个功能。

方法的定义

修饰符，例static,定义该方法的访问类型
返回值类型：如果没有返回值关键字为void
方法名：方法实际名称。
参数类型：相当于占位符，方法调用时传递实参。
方法体：包含具体语句，定义功能。

修饰符  返回值类型  方法名（参数类型 参数名）{
   ...
   方法体
   ...
   return 返回值;
}

方法调用

调用方法：实例方法：对象名.方法名，类方法：直接调用

返回值为void，方法调用为语句

返回值为一个值时，需要赋值

public class Demo1 {
 static int x;

  public static int max(int n1,int n2){
        return n1>n2?n1:n2;
    }
    public static void main(String[] args) {
        System.out.println(x);
        int y=max(5, 20);
        System.out.println(y);
    }
}

方法重载

方法重载：在一个类中，函数名称相同，形参不同。

方法重载规则

方法名称必须相同
参数列表必须不同（个数不同或类型不同或参数排列顺序不同）
方法返回值类型可相同也可不相同
仅返回值类型不同不构成方法重载

命令行传参

package com.wang.method;

public class Demo2 {
    public static void main(String[] args) {
        //System.out.println("Hello world!");
        for(int i=0;i<args.length;i++){
            System.out.println("args["+i+"]"+args[i]);
        }
       }

}

public static void main(String[] args)实质是字符串类型数组args,通过命令行传递。

可变参数

方法声明中，指定参数类型后加一个省略号…
一个方法只能有一个可变参数，可变参数必须在最后面

package com.wang.method;

public class Demo3 {
    public static void main(String[] args) {
        test(1,2,3,2,4,2);
    }
    public static void test(int x,double... i){
        System.out.println(x+" "+i[2]);
    }
}

运行结果 1 2.0

数组

数组声明

数组类型[] 数组名,数组元素类型相同，数组边界[0-Arrays.length-1]

ArrayIndexOutOfBoundsException:数组下标越界异常

dataTypep[] arrayName;
int[] a=new int[10];

声明时在栈中，new 之后才算是分配内存空间在堆中，对数组元素赋值之前是默认值。

//数组静态数组
int[] a={2,34,5};
//动态数组
int[] b=new int[10];
b[0]=10;

数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中

数组工具类Arrays

Arrays.toString(a)、Arrays.binarySearch(a)

面向对象（Obeject-Oriented Programming,OOP）

面向过程：步骤清晰，线性思维，一步一步来，处理简单问题。

面向对象：物以类聚，分类思维。类就是属性加方法。处理复杂问题。

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

抽象

类是抽象的，是对对象的抽象，通俗来说就是将对象的共同属性剥离出来。例如学生类，就是对所有学生对象拥有的属性如学号姓名成绩等抽象成类。

三大特性

封装，将对象的数据封装
继承，子类继承父类的所有
继承，子类继承父类的所有
多态，同一事物表现多种形态

从认识论是先有对象，再有类。
从代码编写现有类，再有对象

方法调用

静态方法可直接通过类调用

package com.wang.oop;

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

package com.wang.oop;

public class Student {
    public static void study(){
        System.out.println("Studying!");
    }
}

非静态方法必须通过实例对象调用

package com.wang.oop;

public class Demo {
    public static void main(String[] args) {
        Student student=new Student();
        student.study();
    }
}

package com.wang.oop;

public class Student {
    public  void study(){
        System.out.println("Studying!");
    }
}

非静态可以调用静态方法，静态不可调用非静态。因为静态方法是在类创建时产生，而非静态对象是在对象创建时产生。

值传递和引用传递

package com.wang.oop;

public class Demo1 {
    public static void main(String[] args) {
        int a=0;
        Demo1 demo1=new Demo1();
        demo1.change(a);
        System.out.println(a);//输出结果为0
    }
    public void change(int x){
        x=5;
    }
}

package com.wang.oop;

public class Demo2 {
    public static void main(String[] args) {
        Stu stu=new Stu();
        System.out.println(stu.name);//输出null
        Demo2 demo2=new Demo2();
        demo2.change(stu);
        System.out.println(stu.name);//输出wang
    }
    public void change(Stu stu){
        stu.name="wang";
    }

}
 class Stu{
    String name;
}

类与对象创建

对象是具体的，类是抽象的一个项目只存在一个main方法

对象.方法

构造器

一个类什么都不写，也存在一个方法即构造方法：无参构造器。
使用new关键字，本质就是调用构造器。
一旦定义有参构造必须显示定义无参构造。
构造器用于初始化值，快捷键alt+insert
this就是指代当前类

package com.wang.oop;

public class Person {
    String name;
    public Person(){

    }

    public Person(String name) {
        this.name = name;
    }
}

package com.wang.oop;

public class Test {
    public static void main(String[] args) {
    Person wang=new Person("wang");
        System.out.println(wang.name);
    }
}

封装

高类聚，低耦合

高类聚：内部数据操作细节隐藏，不允许外部干涉

低耦合：仅少部分方法外部使用

封装

通过操作接口访问，禁止直接访问对象中数据的实际表示，称为信息隐藏。针对私有属性。

私有属性访问或修改时需要提供public的get/set。

package com.wang.oop;

public class Student {
   private String name;
   private int age;
    public void study(){
        System.out.println(this.name+"is studying!");
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
         if(age>120||age<0) System.out.println("Illegal age!");//规避数据错误
        this.age = age;
    }

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

package com.wang.oop;

public class Test {
    public static void main(String[] args) {
   Student wang=new Student();
        wang.setName("wang");
        System.out.println(wang.getName());
    }
}

封装的好处

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

继承

继承本质就是对一批类的抽象

例如人又分为各个国家的人，此时就用到继承。

继承就是扩展(extends).子类是父类的扩展。子类继承父类拥有父类的所有方法和public属性。私有方法无法继承
JAVA中只有单继承，没有多继承
Java中所有类默认是Object类的子类

package com.wang.oop;

public class Person {
    String name;
    public static void say(){
        System.out.println("say something.");
    }
}

package com.wang.oop;

public class Teacher extends Person {

}

package com.wang.oop;

public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.say();

    }
}

super

super用于调用父类的属性和方法

package com.wang.oop;

public class Person {
    protected String name="pei";

    public static void say(){
        System.out.println("say something.");
    }
    public void print(){
        System.out.println("person");
    }

}

package com.wang.oop;

public class Teacher extends Person {
    private String name="佩";

    public void test(String name){
        System.out.println(name);//PEI
        System.out.println(this.name);//佩
        System.out.println(super.name);//pei
        print();//Teacher
        this.print();//Teacher
        super.print();//Person
    }
    public void print(){
        System.out.println("Teacher");
    }

}

package com.wang.oop;

public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.test("PEI");

    }
}

子类的构造器实际上是默认先调用父类的构造器

public class Student{
    super();
    
}

super注意点

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

与this的异同

代表对象不同，this表示调用者本身这个对象
前提条件不同，super只有在继承子类中使用
构造方法，this本类的构造方法，super父类的构造方法.

方法重写

重写都是方法重写与属性无关，子类重写父类的方法

/pei
print();//Teacher
this.print();//Teacher
super.print();//Person
}
public void print(){
System.out.println(“Teacher”);
}

}


```java
package com.wang.oop;

public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.test("PEI");

    }
}

子类的构造器实际上是默认先调用父类的构造器

public class Student{
    super();
    
}

super注意点

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

与this的异同

代表对象不同，this表示调用者本身这个对象
前提条件不同，super只有在继承子类中使用
构造方法，this本类的构造方法，super父类的构造方法.

方法重写

重写都是方法重写与属性无关，子类重写父类的方法

父类引用指向子类 Teacher teacher = new Person();

夏枯无言

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录