> 文档中心 > java基础

java基础


java基础

变量的命名规范

  1. 所有的变量、方法、类名:见名知意
  2. 类成员变量:首字母小写和驼峰原则
  3. 局部变量:首字母小写和驼峰原则
  4. 常量:大写字母和下划线
  5. 类名:首字母大写和驼峰原则
  6. 方法名:首字母小写和驼峰原则

java语言支持如下运算符

优先级()

  • 算术运算符:+,-,*,/(除),%(取余)java中叫模运算,++(自增), --(自减)

    //++    --   自增    自减      一元运算int a=3;int b=a++; //先给b赋值,再自增int c=++a;//先自增,再给b赋值System.out.println(a);  //5System.out.println(b);  //3System.out.println(c);  //5//幂运算2^3 2*2*2 = 8      很多运算用工具类来操作double pow = Math.pow(2, 3);System.out.println(pow); //8
  • 赋值运算符:=

  • 关系运算符:>, =, <=, ==, !=instanceof

  • 逻辑运算符:&& 与, || 或 ,!非

    //与(and)   或(or)     非(取反)boolean a = true;boolean b = false;System.out.println(a&&b); //false   两个变量都为真,结果才为true -----(一假为假)System.out.println(a||b);//true     有一个为真,结果才为true    -----(一真为真)System.out.println(!(a&&b));//true  假为真,真为假//短路运算int c = 5;boolean d = (c<4)&&(c++<4);   //5  c++没有运算
  • 位运算符:&,|, ^, ~, >>, <>>

    /*A = 0011 1100B = 0000 1101----------------A&B = 0000 1100  (A与B 两个位置都是1的时候才是1,否则为0)A|B = 0011 1101  (A或B 一个位置是1才是1,否则为0)A^B = 0011 0001  (按位异或  两个位置相同为0,否则为1)~B  = 1111 0010  (按位取反,和B相反)---------------------------------2*8 怎么算最快<> 右移 相当于/20000 0000     00000 0001     10000 0010     20000 0011     30000 0100     40000 1000     80001 0000     16*/System.out.println(2<<3);   //16
  • 条件运算符:?:

    // X ? Y : Z//如果X==true,则结果为Y,否则结果为Z
  • 扩展赋值运算符:+=, -=,*=,/=

    int a = 10;int b = 20;a+=b;   //a=a+ba-=b;   //a=a-b//字符串连接符System.out.println(""+a+b);  //1020System.out.println(a+b+"");  //30

阅读阿里巴巴开发手册 java API帮助文档

javaDoc

  1. javadoc命令是用来生成自己API文档

    cmd命令:javadoc -encoding UTF-8 -charset UTF-8 Doc.java

  2. 参数信息

  • @author 作者名
  • @verdion 版本号
  • @since指明需要最早使用的jdk版本
  • @param参数名
  • @return返回值情况
  • throws异常抛出情况
  1. 学会查找使用IDEA产生javaDoc文档

java流程控制

1.用户交互Scanner对象

通过Scanner类来获取的用户的输入

基本语法:

Scanner s = new Scanner(System.in);

2.顺序结构

java的基本结构就是顺序结构,除非特别指明,否则就按照顺序一句一句执行。

顺序结构是最简单的算法结构。

语句与语句之间,框与框之间是按从上到下的顺序进行的,它是由若干个依次执行的处理步骤组成的,它是任何一个算法都离不开的一种基本算法结构

3.选择结构

  • if单选择结构

    语法:

    if (布尔表达式){    //如果布尔表达式为true将执行的语句}
  • if双选择结构

    语法:

    if (布尔表达式){    //如果布尔表达式为true将执行的语句}else {    //如果布尔表达式为false将执行的语句}
  • if多选择结构

    语法:

    if (布尔表达式1){    //如果布尔表达式1为true将执行的语句}else if (布尔表达式2){    //如果布尔表达式2为true将执行的语句}else if (布尔表达式3){    //如果布尔表达式3为true将执行的语句}else {    //如果以上布尔表达式都不为true执行代码}
  • 嵌套的if结构

    if (布尔表达式1) {    //如果布尔表达式1为true将执行的语句    if (布尔表达式2){ //如果布尔表达式2为true将执行的语句    }}
  • switch多选择结构

    switch (expression) {    case value: //语句 break;//可选    case value: //语句 break;//可选    //可以任意数量的语句    default://可选 //语句}

字符的本质还是数字

反编译: Java----->calss(字节码文件)------->反编译(IDEA)

4.循环结构

  • while循环

    while(布尔表达式){    //循环内容}
  • do…while循环

    do {    //代码语句}while(布尔表达式);do...while总是保证循环体会被至少执行一次!
  • for循环

    for (初始化;布尔表达式;迭代){    //代码语句}

    练习一:计算0~100之间的偶数和奇数和

    练习二:用while或for循环输出1- 1000之间能被5整除的数,并且每行输出3个

    练习三:打印九九乘法表(1. 打印第一列 2.把固定的1再用一个循坏包起来3.去点重复项,i<=j)拆分问题

  • java5中引入了一种主要用于数组的增强for循环

    for(声明语句:表达式){    //代码语句}主要用于遍历数组或集合

5.break & continue

break用于强行退出循坏,不执行循环中剩余的语句。

continue用于在循坏语句体中,用于终止某次循坏过程,即跳过循坏体中尚未执行的语句,接着进行下一次是否执行循坏的判定。

goto关键字

6.练习

  • 打印三角形

    //打印三角形 for (int i = 1; i =i ; j--) { System.out.print(" ");    }    for (int j = 1; j <=i ; j++) { System.out.print("+");    }    for (int j = 1; j < i; j++) { System.out.print("+");    }    System.out.println();}

java方法详解

1.何谓方法

java方法是语句的集合,它们在一起执行一个功能
  • 是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 在程序中创建,在其他地方被引用

设计方法的原则:最好保持方法的原子性,就是一个方法只完成一个功能,这样有利于后期的扩展

2.方法的定义及调用

  • java的方法类似于其它语言的函数,是一段用来完成特定功能的代码片段

  • 方法的所有部分

    修饰符:修饰符,这是可选的,定义了该方法的访问类型

    返回值类型:方法可能会返回值。没有返回值是关键字void

    方法名:是方法的实际名称

    参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。

    • 形式参数:在方法被调用时用于接收外界输入的数据。
    • 实参:调用方法时实际传给方法的数据

    方法体:方法体包含具体的语句,定义该方法的功能。

    break:跳出switch,结束循环

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

java是值传递 引用传递

https://www.cnblogs.com/zhangshiwen/p/5830062.html

3.方法重载

  • 重载就是在一个类中,有相同的函数名称,但形参不同的函数
  • 方法的重载的规则:
    • 方法名称必须相同
    • 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。
    • 方法的返回类型可以相同也可以不相同
    • 仅仅返回类型不同不足以成为方法的重载

4.命令行传参

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

5.可变参数(不定向)

  • 支持传递同类型的可变参数给一个方法
  • 在方法声明中,在指定参数类型后加一个省略号(…)
  • z一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明

6.递归

递归就是:自己调用自己

利用递归可以用简单的程序来解决一些复杂的问题。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分:

​ 递归头:什么时候不调用自身方法。如果没有头,将陷入死循环。

​ 递归体:什么时候需要调用自身方法。

public static void main(String[] args) {    System.out.println(f(4));}//1! 1//2! 2*1//3! 3*2*1//4! 4*3*2*1//n!= n*(n-1)public static int f(int n){    if (n==1){ return 1;    }else { return n*f(n-1);    }}

数组

1.数组概述

  • 数组是相同类型数据的有序集合
  • 按照一定的向后次序排列组合而成
  • 每个数组元素通过一个下标来访问它们,从来0开始

四个基本特点

  • 长度是确定的,数组一旦被创建,它的大小是不可以改变的
  • 元素必须是相同类型,不允许出现混合类型
  • 数组中的元素可以是任何数据类型,包括基本数据类型和引用类型
  • 数组变量属于引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的成员变量

数组本省就是对象,java中对象是在堆中的,因此数组无论保存原始类型还是其他对象类型,==数组对象本身是在堆中的。

2.数组声明创建

dataType[] arrayRefVar = new dataType[arraySize];

3.数组使用

  • For-Each循环
  • 数组作为方法入参
  • 数组作返回值
   int[] arrays = {1, 2, 3, 4, 5};    //取不到下标    for (int array : arrays) { System.out.println(array);    }    int[] reverse = reverse(arrays);}    //反转数组    public static int[] reverse(int[] arrays){ int[] result = new int[arrays.length]; //反转的操作 for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {     result[j] = arrays[i]; } return result;    }

4.多维数组

  • 多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。

  • 二维数组

    int a[][] = new int[2][5];
  • 解析:a=两行,五列

5.Arrays类

  • 数组的工具类java.util.Arrays(查看jdk帮助文档)

6.稀疏数组

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

  • 稀疏数组的处理方式是:

    记录数组一共都有几行几列,有多少个不同值

    把具有不同值的元素和行列及值记录在一个小规模的数组中,从而缩小程序的规模

public static void main(String[] args) {    //1.创建一个二位数组 11*11  0:没有棋子 , 1:黑棋  2:白棋    int[][] array1 = new int[11][11];    array1[1][2] = 1;    array1[2][3] = 2;    //输出原始数组    System.out.println("输出原始的数组");    for (int[] ints : array1) { for (int anInt:ints) {     System.out.print(anInt+"\t"); } System.out.println();    }    System.out.println("===================================");    //转换为稀疏数组保存    //或获取有效值的个数    int sum=0;    for (int i = 0; i < 11; i++) { for (int j = 0; j < 11; j++) {     if (array1[i][j]!=0){  sum++;     } }    }    System.out.println("有效值的个数:"+sum);    //2.创建一个稀疏数组的数组    int[][] array2 = new int[sum+1][3];    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];     } }    }    System.out.println("稀疏数组");    for (int i = 0; i < array2.length; i++) { System.out.println(array2[i][0] + "\t"  + array2[i][1] + "\t"  + array2[i][2] + "\t");    }    System.out.println("===========================");    System.out.println("还原稀疏数组");    //1.读取稀疏数组    int[][] array3 = new int[array2[0][0]][array2[0][1]];    //2.给其中的元素还原它的值    for (int i = 1; i < array2.length; i++) { array3[array2[i][0]][array2[i][1]] = array2[i][2];    }    //打印    System.out.println("输出还原的数组");    for (int[] ints : array3) { for (int anInt:ints) {     System.out.print(anInt+"\t"); } System.out.println();    }}

7.冒泡排序

public static void main(String[] args) { //嵌套循环,时间复杂度为0(n2) int[] a = {12,234,6543,7,43,34}; int[] sort = sort(a); System.out.println(sort);    } //冒泡排序 //1.比较数组中,两个相邻的元素,如果第一个数比二个数大,就交换的他们的位置 //2.每一次比较,都会产生出一个最大,或者最小的数字 //3.下一轮则可以少一次排序 //4.依次循坏,知道结束    public static int[] sort(int[] array){ //临时变量 int temp = 0; //外层循环,判断我们这个要走多少次; for (int i = 0; i < array.length-1; i++) {   boolean flag = false;//通过flag标识位减少没有意义的比较   //内层循坏,比较判断两个数,如果一个数,比第二数大,则交换位置     for (int j = 0; j< array.length-1-i ; j++) {  if (array[j+1]>array[j]){      temp = array[j];      array[j] = array[j+1];      array[j+1] = temp;      flag = true;  }     }     if (flag==false){  break;     } } return array;    } }

java内存分析

java内存

    • 存放new的对象和数组
    • 可以被所有的线程共享,不会存放别的对象引用
    • 存放基本变量类型(会包含这个基本类型的具体数值)
    • 引用对象的变量(会存放这个引用在堆里面的具体地址)
  1. 方法区
    • 可以被所有的线程共享
    • 包含了所有的class和static变量

面向对象

初识面向对象

面向过程思想:第一步做什么,第二步做什么…;面向过程合适处理一些较为简单的问题

面向对象思想:物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。适合处理复杂的问题

面向的对象的本质就是:以类的方式组织代码,以对象的组织(封装)数据。

抽象

三大特性:封装;继承;多态

对象的创建分析

使用new关键字创建对象:使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中的构造器的调用。

类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的,并且构造器有以下两个特点:

  1. 必须和类的名字相同
  2. 必须没有返回类型,也不能写void

构造器的作用:使用new关键字,本质是在调用构造器;用来初始化值

/*1.类与对象    类是一个模板:抽象,对象是一个具体的实列2.方法    方法的定义和调用3.对应的引用    引用类型    基本类型(8)    对象是通过引用类操作的:栈----->堆4.属性:字段Field   成员变量  默认初始化:    数字:0    0.0    char:u0000    boolean:false    引用:null    修饰符  属性类型  属性名 = 属性值! 5.对象的创建和使用   -必循使用new 关键字创建对象,构造器 Person yxt = new Person();   -对象的属性:yxt.name   -对象方法:yxt.sleep()  6.类:    静态的属性--->属性    动态的行为--->方法*/

面向对象三大特征

封装

该露的露,该藏的藏

​ 我们的程序设计要追求==“高内聚,低耦合”==。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用

封装(数据的隐藏)

​ 通常,应禁止直接访问一个对象中数据的实际表示,而应通过操作接口来分访问,这称为信息隐藏。

属性私有,get/set

意义:

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

继承

概述

继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。

extends的意思是“扩展”。子类是父类的扩展。

Java类中只有单继承,没有多继承。

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

继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。

子类和父类之间,从意义上讲应该具有“is a” 的关系。

Object类

Java中,所有的类,都默认直接或者间接继承Object

super---->父类 this----->当前的

super注意点:

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

this注意点:

  1. this:本身调用者这个对象
  2. super:代表父类对象的应用

前提:

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

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

构造方法:

​ this();本类的构造

​ super();父类的构造!

方法重写

重写都是方法的重写,和属性无关

//在java中,所有的类都默认直接或间接继承Object//人:父类public class Person {   public void test(){System.out.println("父类方法");   }//学生  is  人  派生类 子类//子类继承父类,就会拥有父类的全部方法public class Student extends Person {    // override-->重写    @Override    public void test() { System.out.println("子类方法");    }}  //静态方法和非静态的方法区别很大!    //静态方法:方法的调用只和左边定义的数据类型有关    //非静态:重写    public static void main(String[] args) { Student student = new Student(); student.test(); //父类的引用指向了子类Person person = new Student();person.test();    }}

总结:需要有继承关系,子类重写父类的方法!;

  1. 方法名必须相同
  2. 参数列表必须相同
  3. 修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
  4. 抛出的异常:范围可以缩小,但不能扩大;ClassNotFoundException---->Exception(大)

重写,子类的方法和父类必要一致;方法体不同

为什么需要重写:

  1. 父类的功能,子类不一定需要或者不一定满足!

多态

概述
  • 同一方法可以根据发送对象的不同而采用多种不同的行为方式
  • 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多

多态存在条件

  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
//人:父类public class Person {   public void run(){System.out.println("父类方法run");   }   //学生  is  人  派生类 子类//子类继承父类,就会拥有父类的全部方法public class Student extends Person {    @Override    public void run() { System.out.println("子类方法run");    }    public void eat(){ System.out.println("子类方法eat");    }}  public static void main(String[] args) { //一个对象的实际类型是确定的;可以指向的引用类型就不确定了 //子类 能调用的方法都是自己的或者继承父类的 Student s1 = new Student(); //父类,可以指向子类但是不能调用子类独有的方法 Person  s2 = new Student(); Object  s3 = new Student(); //对象能执行哪些方法,主要看对象左边的类型,和右边关系不大! s2.run(); //子类重写父类的方法,执行子类的方法 s1.run(); s1.eat();    }
多态注意事项:
  1. 多态是方法的多态,属性没有多态性。
  2. 父类和子类,有联系 类型转换异常! ClassCastException!
  3. 存在条件:继承关系,方法需要重写,父类引用指向子类对象!

不能被重写:

  • static 方法属于类,不属于实例

  • final 常量

  • private方法

instanceof

(类型转换)引用类型,判断一个对象是什么类型

抽象类和接口

内部类及OOP实战