JAVA 知识回顾 1

作者: WhiteStruggle | 来源:发表于2020-09-22 00:08 被阅读0次

JAVA 知识回顾 1
回顾java知识
JAVA 知识回顾 2
JAVA 知识回顾 3
Java容器（List、Set、Map）知识点快速复习手册
程序媛在公司的进修之路（二）
2018-06-11继承
Java基础
Android 知识梳理目录 - 好吧，这是一个很"干
Java基础-io知识回顾

Dos命令

dir ：列出当前目录下的文件以及文件夹
md : 创建目录
rd ：删除目录
cd ：进入指定目录
cd.. ：退回到上级目录
cd/ : 退回到根目录
del ：删除文件
exit ：结束dos命令行

删除所有指定文件

例如：当前目录下，删除所有txt文件
del *.txt

环境变量

Path —— 配置javac的启动

ClassPath —— 配置java的使用

在结尾加上 “ ；” ，若没有在环境变量指定的目录找到指定文件，就会去其他目录下寻找

“ . ” 表示当前目录

临时环境变量配置

set命令设置计算机的环境变量

set path=绝对路径

path 为 需要配置的环境变量名
绝对路径 为 临时需要用的文件目录

命名规范

java严格区分大小写

数字不能开头

包名：所有字母都小写，例如：hello
类名接口名：所有单词的首字母大写，例如：StudyDemo
变量名和函数名：第一个单词首字母小写，其余的首字母大写，例如：firstFace
常量名：所有字母大写，例如：IP

数据类型

char ：字符，1个字节，取值范围 -2^7-1 ~ 2^7
float ：单精度，4个字节
double ：双精度，8个字节
boolean ：取值 true，false
byte ：1个字节，取值范围 -2^7-1 ~ 2^7 （-128~127）
short ：2个字节，-2^15-1 ~ 2^15
int ：4个字节，-2^32-1 ~ 2^32
long ：8个字节

函数

格式

修饰符 返回值类型  函数名 ( 参数类型 形参 。。。)
{
    //语句
    return ;
}
使用 返回值类型 为 void 时，不需要返回值return

例如：
public static void demo(int d) {
    
}
public static int demo(int d) {
    return ;
}

函数重载（overload）

在同一个类，允许存在一个或多个的同名函数，他们的参数个数或者参数类型不同

好处：方便阅读，优化程序设计

注意：重载只与参数列表有关，与返回值类型无关

public class Hello
{
        public  static     void main(String[] args)
        {
                System.out.println(add(5,5));//10
                System.out.println(add(5,5,5));//15
        }
        public static  int add(int a,int b) {
                return a+b;
        }
        public static  int add(int a,int b,int c) {
                return a+b+c;
        }
}

使用：

定义的功能相同，但参与运算的未知内容不同
就定义一个函数名称以代表该功能，方便阅读，通过参数列表的不同来区分同名函数

数组

格式1

元素类型[]   , 数组名 = new 元素类型[ 元素个数 或 数组长度 ] ; 

int[] arr = new int[5];

格式2

元素类型[]   , 数组名 = new 元素类型[] { 元素 ，元素 ····} ; 

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

内存结构

栈内存

用于存储局部变量，当数据使用完，所占空间会自动释放

堆内存

数组和对象，通过new建立的实例都存放在堆中
每一个实体都有内存地址值
实体中的变量都有默认初始化值
实体不在被使用，会在不确定的时间内被垃圾回收器回收

方法区

本地方法区，寄存器

数组存贮在堆内存中，变量存贮在栈内存中，通过赋值将数组的地址传到栈中的变量

遍历

获取数组长度 —— length

面向对象

特征：

封装
继承
多态

class People
{
        String name = "Yz";
        int grade = 1526;
       
        int age(int a) {
               return this.grade + a;
        }
}

使用 new 新建对象，每一个对象都占据一个堆内存，改变对象的值不会影响原本的类

匿名对象

当仅调用一次时，使用匿名函数，有利于简化

new People().name;

等同于

People my = new People();
my.name;

当需要使用多次，就必须声明变量对象

People my = new People();
my.name;
my.grade;

封装

隐藏对象的属性和实现细节，仅对外提供公共访问方式

由于直接访问成员变量会造成泄漏问题，因此需要使用private，然后创建方法来让外部访问数据（间接）

private

private —— 私有，权限修饰符，用于修饰类中的成员（成员变量，成员函数），只能在类中使用，不能外部访问

注意：私有仅仅是封装的一种表现形式

public class Hello
{
        public  static     void main(String[] args)
        {
                People a = new People();
                a.Name("Yz");
                a.Grade(1506);
                a.Speck();
        } 
}

class People
{
        private String name ;
        private int grade;
       
        public void Name(String str)
        {
                name = str;
        }
        public void Grade(int num)
        {
                grade = num;
        }
        public void Speck()
        {
                System.out.println("name:"+name+";\ngrade:"+grade+";");
        } 
}

提供对外访问方式，，是因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码的健壮性

构造函数

特点：

函数名与类名相同
不用定义返回值类型
不可以写return语句

作用：
给对象进行初始化

对象一建立就会调用与之对应的构造函数

当一个类中没有定义构造函数时，系统会默认给该类添加一个空参数的构造函数

一个类可以有多重初始化方式

public class Hello
{
        public  static     void main(String[] args)
        {
                People a = new People();//name:null    grade:0
                People b = new People("Yz");//name:Yz    grade:0
                People c = new People("Zs",25);//name:Zs    grade:25
        } 
}

class People
{
        private String name ;
        private int grade;
       People(){
               System.out.println("name:"+name+"    grade:"+grade);
       }
       People(String n){
               name = n;
               System.out.println("name:"+name+"    grade:"+grade);
       }
       People(String n,int g){
               name = n;
               grade = g;
               System.out.println("name:"+name+"    grade:"+grade);
       }
}

区分

构造方法：

在对象建立时就运行，给对象初始化
一个对象建立，只运行一次

普通方法：

在对象调用才会执行，给对象添加对象具备的功能
可以被该对象调用多次

this

当局部变量和构造函数的参数同名，会混淆，不易区分，因此可以使用this来标记局部变量

class People
{
        private String name ;
        private int grade;
       People(String name){
            this.name = name;
            System.out.println("name:"+this.name+"    grade:"+this.grade);
       }
}

this:
代表其所在函数所属对象的引用

this的应用：当定义类中的功能时，该函数内部要用到调用该函数的对象时，这是用this来表示这个对象

public class Hello
{
        public  static     void main(String[] args)
        {
//                判断年龄是否相同
                People a = new People(25);
                People b = new People(20);
                People c = new People(20);
                System.out.println(a.compare(b));//false
                System.out.println(b.compare(c));//true
        } 
}

class People
{
        private int age;
       People(int age){
               this.age = age;
       }
       public boolean compare(People p)
       {
               return this.age == p.age;
       }
}

this()

this 关键字可以用于构造函数之间的相互调用

只能放在构造函数的第一行，因为初始化要先执行

public class Hello
{
        public  static     void main(String[] args)
        {
                People a = new People("Yz",25);
                System.out.println("Name:"+a.GetName());
        } 
}

class People
{
        private String name;
        private int age;
       People(String name){
                this.name = name;
       }
       People(String name,int age){
               this(name);// 等价于 new People() ，调用了初始化 People(String name){}
               this.age = age;
       }
       public String GetName()
       {
               return this.name;
       }
}

构造代码块

作用：给对象进行初始化

对象一建立就运行，且优先级高于构造函数

构造代码块是给所有对象进行初始化

构造函数是给对应对象初始化

一般将公共初始化内容放在构造代码块中，不同的分别放在不同的构造函数中

static(静态)

用法：修饰符，用于修饰成员（成员变量和成员函数），一般是公共内容，

当成员被静态修饰后，多了一种调用方式，直接被类名调用，类名.静态成员

特点：

随着类的加载而加载，（静态会随着类的消失而消失，生命周期长）
优先于对象存在（静态先存在，对象后存在）
被所有对象所共享
可以直接被类名调用

private String name;//成员变量，实例变量
static int age;//静态的成员变量，类变量

实例变量与类变量区别：

存放位置

类变量随着类的加载而存在与方法区中，随着类的消失而消失

实例变量随着对象的建立儿存在于堆内存中

生命周期

类变量生命周期长，随着类的消失而消失

实例变量随对象的消失而消失

注意：

静态方法只能访问静态成员
静态方法中不可以写this，super关键字

因为静态优先于对象存在，所以静态方法不可以出现this

主函数就是静态的

静态

优点：

对象的共享数据进行单独空间的存储，节省空间
可以直接被类名调用

缺陷：

占内存
访问存在局限性，只能访问静态内容

主函数

是一个特殊的函数，作为程序的入口，可以被jvm调用

固定格式，除了args可以自己定义，这是参数名
public static void main(String[] args)
{
        
}

static : 代表主函数随类的加载而存在
void ：没有返回值
main ：不是关键字，但为一个特殊的单词，可以被jvm识别
(String[] args) ：函数参数，参数类型为一个数组，该数组的元素时字符串，字符串类型的数组

jvm在调用主函数时，传入的是new String[0];

给main函数传入数据，通过java.exe

当使用javac编译文件，得到class文件，使用java来执行class文件，在后边加上一些数据（字符串）

public class Main {
    public static void main(String[] args)
    {
        for (int i=0; i<args.length;i++)
        {
            System.out.println(args[i]);
        }
    }
}

E:\IDEA\Hello\src\demo>java Main.java he llo wo rld !
he
llo
wo
rld
!

静态的使用

定义静态变量：
当对象中出现共享数据时，该数据被静态所修饰

定义静态函数：当功能内部没有访问到静态数据（对象的特有数据），则该功能可以定义成静态

静态的应用

每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用

对象是用于封装数据的，让程序更加严谨，是不需要对象的，可以将方法都定义为static 的，直接通过类名调用

有时为了更加严谨，强制让该类不能建立对象，可以通过将构造函数私有化完成

class Num{
    private Num(){};//私有化，不能创建对象
    public static  void max(){
         ····
    }//静态封装，直接通过类名调用
    ·····
}

静态代码块

格式：

static
{
    执行语句
}

特点：
随着类的加载而执行，只执行一次

执行：

优先于主函数
只能访问静态内容

帮助文档的制作javadoc

使用javadoc.exe

java类的标识：

注释方式：
/**
    ······
/*

@author Yz //表示作者是Yz

@version v1.0 //表示版本为1.1

@param 参数 描述信息 //介绍对象方法的参数

@return 描述信息//介绍对象方法的返回值

注意：

自己书写的类需要是 public ，使其权限增强，否则会报错

字符编码格式，UTF-8与GBk的冲突

javadoc -d 文件位置 -author -version Num.java

-d 用于设置路径
文件位置 ： 可以是相对路径或者绝对路径 ，文件路径可以不存在，当执行是会自动创建相应的目录
-author 用于强调 作者
-version  用于强调  版本

成生成一个文件夹，通过index.html查看生成的说明书

例如：

/**
 * 这是一个num工具类
 * @author Yz
 * @version v1.0
 */
public class Num{
    /**
     * 私有化构造函数，禁止创建对象
     */
    private Num(){};
    /**
     * max求出数组中的最大值
     * @param arr 传递一个数组，得到其中最大值
     * @return 返回最大值
     */
    public static  int max(int[] arr){
        int max = 0;
        for(int i = 0;i<arr.length;i++)
        {
            if(max < arr[i])
            {
                max = arr[i];
            }
        }
        return max;
    }

    /**
     * min求出数组中的最小值
     * @param arr 传递一个数组，得到其中最小值
     * @return 返回最小值
     */
    public  int min(int[] arr){
        int min = 0;
        for(int i = 0;i<arr.length;i++)
        {
            if(min > arr[i])
            {
                min = arr[i];
        }
        }
        return min;
        }
}

javadoc -d moreJava -author -version Num.java

对象初始化过程

当new对象，会加载相应的类，会开辟一段堆内存

先找到class文件并加载到内存中
静态代码块执行
堆内存中开辟空间，分配内存地址
在堆内存中建立对象的特有属性，并进行默认初始化，
对属性进行心事初始化
对对象进行构造代码块初始化
对对象进行构造函数进行初始化
将内存地址赋给栈内存中的变量

public class Main {
    public static void main(String[] args)
    {
        new People("Hello World!!!");
    }
}
class People{
    private String name;
    People(String name){
        System.out.println("a");
    }
    {
        System.out.println("b");
    }
    static
    {
        System.out.println("c");
    }
}

输出结果：
c
b
a

对象调用成员的过程

非静态使用 this

this.name

静态使用类名

Person.name

设计模式

解决某一类问题最行之有效的方法

java中有23种设计模式

单例设计模式

解决一个类在内存中只存在一个对象

保证对象唯一：

避免过多建立对象，应先禁止其他程序建立该类的对象
为了其他程序可以访问到该类对象，只好在本类中自定义一个对象
为了方便其他程序访问该类的自定义对象，可以提供一些访问方式

有两种格式：饿汉式，懒汉式

推荐使用——饿汉式

/**
实现过程：
    1. 将构造函数私有化
    2. 在类中创建一个本类对象
    3. 提供方法获取到该对象
*/

// 格式一： 饿汉式
// 类一加载进内存，就会创建对象
class People{
    private People(){};
    private static People p = new People();

    public static People getP(){
        return p;
    }
}

// 格式二：懒汉式 
// 方法被调用时，对象才初始化
//也叫作对象的延时加载

//类一加载进内存，People对象还不存在，只有调用相应的方法才会调用
class People{
    private static People p = null;
    private People(){};

    public static People getP(){
        if(p == null)
        {
            synchronized (People.class)//利用多线程，解决一些中断问题
            {
                if (p == null)
                    p = new People();
            }
        }
        return p;
    }
}

当一个类仅仅需要产生一个对象（单例），保证其他的内容不变的基础上，添加以上的三步:

public class Main {
    public static void main(String[] args)
    {
        People p1 = People.getP();
        People p2 = People.getP();
        p1.setAge(25);
        System.out.print(p2.getAge());//25
    }
}
class People{
    private int age;
    
    public void setAge(int age)
    {
        this.age=age;
    }
    
    public int getAge()
    {
        return this.age;
    }
    private People(){};
    private static People p = new People();

    public static People getP(){
        return p;
    }
}

JAVA 知识回顾 1
Dos命令 dir ：列出当前目录下的文件以及文件夹 md : 创建目录 rd ：删除目录 cd ：进入指定目录 ...
回顾java知识
对于java的学习，这么久没有复习还记得多少。还是得回顾一下自己所学的知识，在第一章的时候，接触了什么是java，...
JAVA 知识回顾 2
面向对象继承关键字： extends 特点：提高代码的复用性让类与类之间产生关系，才有了多态的特性注意：...
JAVA 知识回顾 3
Object类是所有对象的直接或者间接父类该类中定义的是所有对象都具备的功能 equals(object ob...
Java容器（List、Set、Map）知识点快速复习手册
前言本文快速回顾了Java中容器的知识点，用作面试复习，事半功倍。其它知识点复习手册 Java基础知识点面试手...
程序媛在公司的进修之路（二）
第二周仍然是学习，任务如下：1.java基础知识回顾：java编程思想7-15章，并用面向对象的思想模拟汉诺塔游戏...
2018-06-11继承
今天，学习了java的继承。回顾了一些继承的知识。但晚上还得系统的看一下。还需要查询的知识 1.float...
Java基础
写了一段时间java，回顾下基础知识 C1 在命令行运行Java 基本数据类型基本类型是Java语言里的一种内置...
Android 知识梳理目录 - 好吧，这是一个很"干
一、Java 知识梳理 Java&Android 基础知识梳理(1) - 注解Java&Android 基础知识梳...
Java基础-io知识回顾
Java拾遗系列- io知识简介 io分类及相关实例3.总结 1.简介 2.io分类及相关应用 2.1 io流...

JAVA 知识 回顾 1