Java基础学习笔记

Java基础学习

基础数据类型

类型	具体数据
逻辑类型	boolean(ture/false)
整数类型	byte(1字节)、short(2字节)、int(4字节)、long(8字节)
字符类型	char(2字节)
浮点类型	float(常量后必须有f/F)、double

Java方法

Java方法是类似于c函数，包含于对象或类中，在程序中被创建，在其他地方被引用

public static int add(int a, int b){
	return a+b;
}//创建一个add功能的方法

设计方法原则：保持方法的原子性，即一方法一功能。

方法的定义

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

异常抛出

public void readFile(String file) throws IOException{
    
} 

方法的调用

静态方法 static

直接 类名.方法名

非静态方法

需要先实例化这个类：new class();//将这个类实例化

万能公式：

//对象类型 对象名 = 对象值；
Class class = new Class();
class.say();

**需要注意的点:**若在方法内调用方法，不能够在static的方法调用常规方法，因为static是和类一起加载的而常规的方法是在类实例化后才存在。

值传递和引用传递：

值传递只传进去一个值，而引用传递传进去对象，可以直接对对象里的元素进行修改。

命令行传参

1.直接使用cmd至java文件路径可通过javac xxx.java编译得到xxx.class文件

2.然后直接使用Java xxx 命令执行，如果class文件在包内，需回退至包的路径加上包名进行执行

3.传参直接在java xxx命令+空格+参数

可变参数

同一方法名称下参数类型或数目不同都是不同的方法

public void method(){}
public void method(int a,int b){}
public void method(int a,double b){}
public void method(double a,double b,double c){}

但这样做效率不高，所以从jdk1.5开始，Java开始支持传递可变参数给一个方法。

使用方法

在方法声明中，在指定参数类型后加一个省略号(…)。

一个方法中只能有一个可变参数，它必须是方法的最后一个参数。

public static int max(double... numbers){}
public static int printmax(int a,double... numbers){}

递归

同c

数组

定义：略

数组的声明创建

声明数组变量的语法

dataType[] arrayRefVar;//首选方法
dataType arrayRefVar[];//效果相同但不首选

Java语言中使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize]; 

数组的初始化

数组分为静态初始化和动态初始化

静态初始化为在声明的同时就附上值(创建+赋值)：

int[]={1,2,3,4,5}

动态初始化包含了默认初始化即未初始化的元素默认初始化为0(int 数组时)：

int[] array = new int[10];
array[1]=10;
//此时array数组其他元素均被默认初始化为0

数组的使用

1. for-each循环遍历

   for(int i=0;i<n;i++){
       array[i].....
   }//法一
   for(int x : array){
       System.out.println(x);
   }//法二，主要用于JDK1.5时没有下标的情况
   

2. 数组作方法入参

   //打印数组元素
   public static void printarray(int[] array)
       for(int i=0;i<array.length;i++){
   	System.out.println(array[i]);
       }
   

3. 数组作返回值

   //反转数组
   public static int[] reverse(int[] array){
   	int[] result =new int[5]
       for(int i=0;i<array.length;i++){
           result[array.length-i]=array[i];
       }
       return result;
   }
   

多维数组

同c语言，不做赘述

数组的小结

1. 长度确定，创建后不可变。
2. 其中元素必为相同类型。
3. 其中元素可以是任何数据类型，包括基本类型和引用类型。
4. 数组不可越界。
5. 数组变量本身属引用类型，数组也可看成是对象，数组中没个元素都相当于该对象的成员变量。 数组本身就是对象，Java中对象就是在堆中的。

Arrays类

• 数组的工具类
• 可通过查看JDK帮助文档查看源码
• Arrays类中的方法采用的都是static修饰的静态方法，在使用时可以直接用类名进行调用，而不必要使用对象来调用。
• 具有以下常用功能：
  • 给数组赋值：fill方法。
  • 堆数组排序：sort；方法，按升序。
  • 比较数组：通过equals方法比较数组中元素值是否相等。
  • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

稀疏数组

当一个数组中大部分元素为0，或者为同一值的数组时，可以用稀疏数组来保存该数组。

稀疏数组的处理方式

1. 记录数组一个有几行几列，有多少个不同值

2. 把具有不同值的元素和行列及值记录

   ​

   如下图：

实例

需求编写五子棋游戏，有存盘退出和需上盘的功能

**分析：**因为该二维数组的很多值是默认值0，记录了很多没用的值

**解决：**稀疏数组

code：

//创建二维数组
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
 
//转换稀疏数组
//记录有效值的个数
int sum = 0;
for(int i = 0; i < 11; i++){
    for(int j = 0; j < 11; j++){
		if(array1[i][j] != 0){
            sum++;
        }
    }
}

//创建稀疏数组
int[][] array2 = new int[sum+1][3];//第0行需要存原数组的行列数和有效元素数，故得sum+1。
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[i].length; j++){
		if(array1[i][j] != 0){
            count++;
            array2[count][0] = i;
            array2[count][1] = j;
            array2[count][2] = array1[i][j];
         }
    }
}

//读取稀疏数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//将其中元素还原
for(int i = 1; i < array[0][2]; i++){
	array3[array2[i][0]][array2[i][1]] = array2[i][2];
}

Java内存分析

堆

存放new的对象和数组。

可以被所有线程共享，不会存放别的对象引用。

栈

存放基本变量类型（会包括这个基本类型的数值）

引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区

可以被所有线程共享

包含了所有class和static变量

相关实例

1.声明数组：在栈中加入数组的名字

2.创建数组：在堆中开辟了一块数组大小的空间

3.给数组中元素赋值

int[] array;
array=new int[10];
array[0]=1;
...

Java面向对象

什么是面向对象编程

本质就是：以类的方式组织代码，以对象的组织（封装）数据。

抽象

三大特性：

• 封装
• 继承
• 多态

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

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

类与对象的创建

file:Student.java

public class Student {

    //属性：字段
    String name;//null
    int age;//0

    //method
    public void study(){
        System.out.println(this.name+" is studying");
    }

}

flie:App.java

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

        //类：抽象的，实例化
        //类实例化后会放回一个自己的对象
        //student对象就是Student类的具体实例
        Student student = new Student();

        student.name = "LiHua";
        student.age = 12;

        System.out.println(student.age);
        System.out.println(student.name);

    }

}

构造器：

1. 与类名相同
2. 没有返回值

//Person.java
public class Person {
}
//person.class
public class Person {
    public Person() { /* compiled code */ }//此处为自动生成的隐式构造
}

作用：

1. 使用new关键字，本质是在调用构造器(构造方法)
2. 初始化对象值

注意点：

​ 定义有参构造后，如果想使用无参构造，必须显示的定义一个无参构造。

public class Person {

    String name;

    //无参构造
    public Person(){
    }

    //有参构造
    public Person(String name){
        this.name = "Alin";
    }

}

快捷键：alt+insert 可自动生成构造器

this. 代表当前类

三大特性：

1. 封装性：

程序设计要追求 “高内聚，低耦合”。高内聚：类内部的数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装通常来说就是要禁止直接访问一个对象中的数据的实际表示，而应该通过操作接口来访问，这称为数据的隐藏。

核心：属性私有，get/set

import java.security.PrivateKey;

public class Student {

    //属性私有  private
    private String name;//null
    private int age;//0

    //get/set
    public String getName(){
        return this.name;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        if(age>120 || age<0){
            this.age = 3;//输入数据不合法时
        }else{
            this.age = age;
        }
    }
    public int getAge(){
        return this.age;
    }
}

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

        Student student = new Student();

        /*
        不能直接对数据进行操作
        student.name = "LiHua";
        student.age = 12;
        */
        //通过接口进行
        student.setName("LiHua");
        student.setAge(12);
        System.out.println(student.getAge());
        System.out.println(student.getName());

    }

}

意义：

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

2. 继承

子类是父类的扩展。

继承是类与类之间的一种关系，除此之外还有依赖、组合、聚合等。

继承关系的两个类，一个为父类（基类）一个为子类（派生类），子类继承父类，子类是父类的拓展，用extends关键字来表示。

子类和父类的关系可以通俗的理解为"什么是什么"。

public class Person {

    //父类

    private int money = 10_0000_0000;
    public void say(String word){
        System.out.println(word);
    }

    public void setMoney(int money){
        this.money = money;
    }
    public int getMoney(){
        return this.money;
    }
}

public class Student extends Person{

}

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

        Student student = new Student();
        //student类内并没有写say()方法，但是由于Student类是Person类的子类，所以Student类继承了Person类的所有方法
        student.say("ababa");
        System.out.println(student.getMoney());
    }
}

java中只有单继承，无多继承，（一子对应一父）

CTRL+H:可打开

查看继承关系(姑且先这么称呼)

**Object类：**在Java中，所有的类都默认间接或直接继承Object类。

super：

public class Person {

    //父类
    protected String name = "lin";

}

public class Student extends Person{
    private String name = "xiaoa";
    public void test(){
        System.out.println(this.name);
    }
    public void test1(){
        //输出父类中不是privated的数据
        System.out.println(super.name);
    }
}

注意点：

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

vs this

​ 代表的对象不同：

​ this：本身调用者这个对象

​ super：代表父类对象的应用

​ 前提

​ this：没有继承也可以使用

​ super：只能在继承条件下才可以使用

​ 构造方法

​ this(): 本类的构造

​ super(): 父类的构造

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

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

重写子类的方法必须与父类的方法名一致；方法体不同。

需要重写的理由：

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

Alt+Insert ； override

public class A {
    public void test(){
        System.out.println("A");
    }
}

public class B extends A{
    public void test(){
        System.out.println("B");
    }
}

3. 多态

Java-idea快捷键

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

sout => System.out.println();

fori => for(int i=0;i< ;i++){}

for.100 => for(int i=0;i<100;i++){}