JAVA学习

1、JAVA基础学习

1.1、为什么配置环境变量

运行文件的命令只能在文件目录下执行，每一次都要找到执行文件的目录，比较麻烦。所以配置环境变量。配置环境变量是在控制面版的系统属性的环境变量中设置。其中设置环境变量名与对应的地址（到bin的上一级目录下）。还要设置path环境变量。

1.2、一些常见的命令

cmd 打开命令行

d:切换到d盘目录下

dir查看当前文件夹的目录

cd 目录名   进到某个目录

cls  清除屏幕

cd ..  返回上一级目录

mkdir  testdir\subdir 或者md  testdir\subdir创建testdir文件夹下subdir 文件

rd /s testdir        删除目录不为空的文件夹

exit        退出

 .java         java文件的后缀名。一个文件只能有一个public类，该类有一个main方法。当运行该文件时，会默认调用该方法

javac  运行.java文件

public修饰的文件，类名与文件名一致

生成注释

 1.3、变量

变量：变量类型：开辟空间的大小，变量名：地址，赋值

标识符：字母、数字,下划线，英文货币符号，不能以数字开头

1.4、 数据类型

数据类型分为基础数据类型（8种）与引用数据类型（3种）

基本数据类型：整数型（4种），小数型（2种），字符型,布尔型

整数型：（用二进制计数）

byte b1=100  //用一个字节表示，范围-128-127

short b2=1000  //用两个字节表示，范围-32768-32767

int b3=1000  //用四个字节表示，范围-2147483648-2147483647

long b4=1000L //用八个字节表示,需要在后面加上L,否则认为是整数

小数型：（用科学计数法 n=m*x^r）

float c1=0.16  //c1是double型，默认小数是double型，定义浮点型需要在后面加一个f

float c2=0.16f  //利用4位字节记录，也可以将一个long类型赋值给float型，只是计数方式不同

double c3=0.16  //利用8位字节记录

字符型：

char a='A'  //利用2位字节记录,范围0-65535

char a=65 //范围0-65535

布尔型：

boolean islogin=true  //利用4位字节记录,用一个整型的0或1来记录true与false

引用数据类型：字符串型，数组型，对象型

1.5、运算符与变量交换

注意点：求a/b的结果

（double）a/b

将a与b进行交换

a=a+b                b=a-b                a=a-b

1.6、处理输入输出

 

1.7、eclipse的使用

下载--创建项目--修改jdk版本--修改jde环境--修改编译环境

创建包--创建类

1.8、函数调用

函数必须写在类里面，一个函数里面不能再定义另一个函数

函数里面的形参时基本类型，表示值传递，修改形参不会对真实变量存在影响。

函数里面的形参时引用类型，表示引用传递，修改里面的形参数据，会影响外面的引用类型数据。

方法的定义需要用static修饰

1.9、数组与数组的方法

定义

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

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

//数组扩容

a=Arrays.copyOf(a,a.length*2);

Arrays.toString(a)

//数组作为参数时，传递的是地址。变量扩展运算符，可变长度

public static void add(int... a) {

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

}

二维数组

int[][] array=new int[3][5]

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

int[][] array=new int[3][]

num[i]=new int[5] 

2、面向对象

 

 

 

2.1、对象包含属性与方法

类：是对象的模板，是对象的类型。规定了对象有哪些属性与方法。为对象的共性的特征与行为

//Dogobj.java

public class Dogobj {

String brand;

String dogname;

int age;

String color;

public void eat() {

System.out.println( dogname +"在吃东西");

}

public void sleep() {

System.out.println(color+age+dogname+"在睡觉");

}

}

//test.java

Dogobj dog=new Dogobj();

dog.eat();

 

2.2、方法重载

一个类中定义了一个函数名的多个方法，只是参数个数或许参数类型不同，与形参名、修饰符和返回值没有关系。一个方法名可以执行多个方法，根据不同的参数执行不同的方法。取决于参数的不同。典型的例子如定义多个构造函数。

2.3、构造方法

带参构造函数与无参构造函数

this关键字：当前对象，谁调用方法就指向谁

2.4、封装

私有属性：private。不可直接访问属性，只允许类的内部修改与访问，向外暴露方法

“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

2.5、继承 extends

继承：单根性与传递型

调用父类的方法与属性

super.属性  super.方法

私有属性能够被子类继承但是不能被子类访问

 构造函数不会被继承，但是会先调用父类的构造函数(没有构建父类)，构造子类

super（参数？）调用父类的构造

this(参数？)调用子类的构造

 2.6、重写

重写方法：父类的方法不能满足子类的方法

访问权限可以放大不可以缩小，返回类型可以是和父类一样，也可以是父类的子类，参数类型必须和父类一致，否则就变成了重载。

 被**static(属于类，不属于实例)，final(常量方法)，private(私有)**修饰的方法不能重写

2.7、 多态

同一方法可以根据发送对象的不同而采用不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用可以有很多

多态存在条件：有继承关系；子类重写父类方法；父类引用指向子类对象

 多态的运用

1、使用父类类型作为形参实现多态，使方法参数的类型更为宽泛

2、使用父类作为方法返回值实现多态，使方法可以返回不同子类对象

 

• 注意点：
  1. 多态是方法的多态，没有属性的多态
  2. 父类和子类，有联系 类型转换异常: ClassCastException
  3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！

2.8、类型转换

Person obj = new Syudent(); //只能用Person方法（重写了用子类重写过的方法）

(Syudent)obj.go(); //强转之后可以用Student方法(Student->go())

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型，会丢失自己原来的一些方法
3. 把父类转换为子类，向下转型，强制转换，才调用子类方法
4. 方便方法的调用(转型)，减少重复的代码，简洁。

2.9、Static

• 静态变量可以直接用类名访问，也称类变量。
• 静态变量(或方法)对于类，所有对象（实例）所共享。
• 静态区代码 加载类时一起被初始化，最早执行且只执行一次（第一次new）。

2.10、抽象类(abstract)

abstract修饰的类就是抽象类，修饰的方法就是抽象方法。
抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。
抽象类不能使用new来创建对象，它是用来让子类继承的。
抽象方法只有方法的声明，没有实现，让其子类实现。
子类继承抽象类，必须实现抽象类的所有方法，否则该子类也要声明为抽象类。

抽象类有构造器，可以派生子类

抽象类的意义：约束，提高开发效率。但是类只能单继承，所以有局限，用的不多

 2.11、final常量

 2.12、接口(interface)（没有构造函数）

接口为空时，表示标志，为常量时，表示常量接口。为函数时，表示约束。

接口的本质是约束，可以多实现，也可以继承extends

public class Student inplements IA,IB {    

    IA  firstable;

    IB  secondable;

    } 

接口回调

拥有方法与回调函数，当别人要调用该函数时，再去实现该方法

2.13、内部类

类的五大成员：属性 方法 构造器 代码块 内部类

一个类的内部又完整的嵌套了另一个类结构。内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

class Outer{//外部类
    private int n1 = 100;
    public Outer(int n1){
        this.n1 = n1;
    }
    public void m1(){
        System.out.println("m1()");
    }
    {
        System.out.println("代码块");
    }
    class Inner{//内部类，在Outer类的内部
 
    }

二、内部类的分类
1.定义在外部类局部位置上(比如方法内)
        1)局部内部类(有类名)

        2)匿名内部类(没有类名，重点！！！！)

2.定义在外部类的成员位置上:
        1)成员内部类(没用static修饰)

        2)静态内部类(使用static修饰)
参考：【JAVA学习笔记】42 - 内部类（难点，重点）-CSDN博客

局部内部类

局部内部类是定义在外部类的局部位置，比如方法中或者代码块，并且有类名。

本质仍然是一个类，可以直接访问外部类的所有成员，包含私有的。不能添加除final外的访问修饰符。

匿名内部类！！！

说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名

(1)本质是类 (2)内部类 (3)该类没有名字（其实也有 系统分配 但我们看不见也无法调用）(4)同时它还是一个对象。适用于只定义 一个子类对象的场景

      

成员内部类

 说明:成员内部类是定义在外部类的成员位置，并且没有static修饰。  (public、protected、 默认、private),因为它的地位就是一个成员。

静态内部类

静态内部类是定义在外部类的成员位置，并且有static修饰

2.14、包装类：拥有属性与方法

2.15、Object类方法

2.16、String类

可变长字符串

1. StringBuffer: JDK1.0 线程安全,效率低
2. StringBuilder: JDK5.0 线程不安全,效率高
3. 字符串拼接使用+时，会不停的开辟空间

//拼接26个大写字母并输出
        StringBuilder sb = new StringBuilder();
        for (char c = 'A'; c <= 'Z'; c++) {
            //将当前遍历内容追加至可变长字符串末尾
            sb.append(c);
        }
        System.out.println(sb);
        //将可变长字符串转变为String类型
        String s = sb.toString();

2.17、Date

java.util.Date

创建date对象，无参构造默认创建此时此刻时间

Date date = new Date();

方法一：getTime() 获取
从1970年1月1日 0时0分0秒到此刻毫秒值

SimpleDateFormat类
// 带参指定格式的构造器
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

Calendar类

Calendar calendar=Calendar.getInstance();

2.18、System类
参考：【Java基础】了解System类及其常用方法的作用_java system.free()作用-CSDN博客