java基础
java基础
变量的命名规范
- 所有的变量、方法、类名:见名知意
- 类成员变量:首字母小写和驼峰原则
- 局部变量:首字母小写和驼峰原则
- 常量:大写字母和下划线
- 类名:首字母大写和驼峰原则
- 方法名:首字母小写和驼峰原则
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
-
javadoc命令是用来生成自己API文档
cmd命令:
javadoc -encoding UTF-8 -charset UTF-8 Doc.java
-
参数信息
- @author 作者名
- @verdion 版本号
- @since指明需要最早使用的jdk版本
- @param参数名
- @return返回值情况
- throws异常抛出情况
- 学会查找使用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的对象和数组
- 可以被所有的线程共享,不会存放别的对象引用
- 栈
- 存放基本变量类型(会包含这个基本类型的具体数值)
- 引用对象的变量(会存放这个引用在堆里面的具体地址)
- 方法区
- 可以被所有的线程共享
- 包含了所有的class和static变量
面向对象
初识面向对象
面向过程思想:第一步做什么,第二步做什么…;面向过程合适处理一些较为简单的问题
面向对象思想:物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。适合处理复杂的问题
面向的对象的本质就是:以类的方式组织代码,以对象的组织(封装)数据。
抽象
三大特性:封装;继承;多态
对象的创建分析
使用new关键字创建对象:使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认的初始化以及对类中的构造器的调用。
类中的构造器也称为构造方法,是在进行创建对象的时候必须要调用的,并且构造器有以下两个特点:
- 必须和类的名字相同
- 必须没有返回类型,也不能写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
意义:
- 提高程序的安全性,保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性增加了
继承
概述
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。
extends的意思是“扩展”。子类是父类的扩展。
Java类中只有单继承,没有多继承。
继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends来表示。
子类和父类之间,从意义上讲应该具有“is a” 的关系。
Object类
Java中,所有的类,都默认直接或者间接继承Object
super---->父类 this----->当前的
super注意点:
- super调用父类的构造方法,必须在构造方法的第一个
- super必须只能在出现在子类的方法或者构造方法中!
- super和this不能同时调用构造方法!
this注意点:
- this:本身调用者这个对象
- 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(); }}
总结:需要有继承关系,子类重写父类的方法!;
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大但不能缩小:public>Protected>Default>private
- 抛出的异常:范围可以缩小,但不能扩大;ClassNotFoundException---->Exception(大)
重写,子类的方法和父类必要一致;方法体不同
为什么需要重写:
- 父类的功能,子类不一定需要或者不一定满足!
多态
概述
- 同一方法可以根据发送对象的不同而采用多种不同的行为方式
- 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
多态存在条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
//人:父类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(); }
多态注意事项:
- 多态是方法的多态,属性没有多态性。
- 父类和子类,有联系 类型转换异常! ClassCastException!
- 存在条件:继承关系,方法需要重写,父类引用指向子类对象!
不能被重写:
-
static 方法属于类,不属于实例
-
final 常量
-
private方法
instanceof
(类型转换)引用类型,判断一个对象是什么类型