Java入门级基础教学（史上最详细的整合）
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
目录
一基础语法
1.“Hello word”
1.首先下新建一个文件夹存放代码
2.新建一个Java文件来存放Java的相关代码。
注意点文件的后缀名为Java（本文为Hellow.java
public class Hello {
//class后面的名字应该和文件名保持一致否则会报错
public static void main(String[] args){
System.out.print("Hello Word");
//System.out.print("XXX")打印输出语句
}
}在cmd的根目录i下进行执行的时候采用javac Hellow.java 来执行文件会生成一个class文件接着执行java Hellow来执行编译文件就会自动的打印输出Hello word。
2.Java的运行机制
1.编译型直接编译成系统可以理解的语言。这样的执行速度会更快。
2.解释型把机器不懂的地方进行解释从而来进行执行。
Java编译器将准备好的源文件编译成了class文件真正被执行的应该是class文件。此时将class文件放入到类加载器放在Jvm中进行。字节码校验器来进行代码的校验校验完成若没有了错误此时的解释器便开始工作将我们的程序解释给操作系统从而进行解读。
3. Java基本语法
1.注释、标识符、关键字
注释（以代码为例
public class HelloWord {
public static void main (String[] args){
//单行注释只能注释一行内容
//输出一个HelloWord
System.out.println("Hello Word!");
/*为多行注释可以注释多行内容*/
/*System.out.println("Hello Word1!");
System.out.println("Hello Word2!");
*/
//JavDdoc文档注释
/**文档注释可以加功能
* @Author 代码贩子、 --南京邮电大学
*/
}
}（标识符Java中所有的组成部分都需要名字。类名变量名以及方法名都称之为标识符。
注意点所有的标识符都应该以（A——z、$、或者是下划线开始的。
首字符之后可以是（A——z、$、或者是下划线的组合。
关键字不可以作为名字。
可以是中文名字但是一般不采用因为太Low会被同行看不起。
标识符是大小写敏感的。
2.数据类型（四类八种
Java为一款强类型的语言所有变量的使用必须严格的符合固定所有的变量只有被定义后才能进行使用。
4.类型转换
重点提示（有人问为什么long占的字节比float的多还排在float后面？因为在发生转换的时候小数的优先级要大于整数。不同类型的数据结构先转化为同一类型的然后再进行计算。
强制转换分为两种一种是从低到高的转换方法一种是从高到低的转换方法。
1.自动转换
显式（规则数据范围从低到高代码不需要进行处理并且直接可以完成转换。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
//直接输出一个整数默认是int型
System.out.println("30");
//直接输出一个小数默认是double型
System.out.println("3.12");
//（1左边是long类型右边是int类型
//（2=进行赋值右边默认给左边 int——>long满足从低到高的转换规则
//（3这一行代码发生了自动转换
long name1=100;
System.out.println(name1);
//(1)右边是float类型左边是double类型
//（2float->double满足从低到高的转换规则
//（3所以发生了自动转换
double name2=3.1415926F;
System.out.println(name2);
//(1)右边是long类型左边是float类型
//（2long->float,满足从低到高的转换规则
//（3所以发生了自动转换
float name3=30L;
System.out.println(name3);
}
}
2.强制转换
代码需要进行处理不能够自动的完成转换。
格式（范围小的类型+范围小的变量名=（范围小的类型+原本范围大的数据
注意（1在进行前置转换的时候可能会出现内存溢出、精度丢失等现象。
（2byte/short/char这三种类型可以进行数学计算。
（3byte/short/cha这三种类型在进行运算的时候首先会被默认为是int卡类型。
（4布尔类型不可以进行任何的数据转换。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
//（1右边是long类型左边是int类型
//（2long->int 不是从高到低所以需要进行强制转换
//（3格式（较小的数据类型+较小的变量名=（较小的数据类型+（原本范围较大的数据
int nume1 = (int) 100L;
System.out.println(nume1);
//（1右边是int类型左边是int类型
//（2int->byte
//（3格式（较小的数据类型+较小的变量名=（较小的数据类型+（原本范围较大的数据
//写法一
int a = 200;
byte b = (byte) a;
//写法二
byte nume2 = (byte) 200;
//输出值为-56
//原因为200超过了byte的数据范围发生了内存溢出的现象所以在发生强制转换之后的输出值为负数。
System.out.println(b);
System.out.println(nume2);
float c = 3.14f;
int d = (int) c;
//此时的输出值为3
//因为在强制转换的时候float->int会发生精度丢失的问题所以最后的输出值为3而不是3.14。
System.out.println(d);
//输出的值为97
char e ='a';
int f= (int)e;
System.out.println(f);
//输出的值为b
int g= f+1;
System.out.println((char) g);
//应该是20000000000但是实际的结果输出的为一个负数
//那是因为计算的时候溢出了
int moeny = 10_0000_0000;
int years = 20;
int total = moeny*years;
System.out.println(total);
//虽然发生了自动转换还是输出的为负数
//因为默认是int并且在转换之前就已经出现了问题。
long total2 = total;
System.out.println(total2);
//此时输出的结果为正确的数值
//输出的结果为20000000000
//解决方法先把一个数据转化为long类型
long total3 = moeny*(long)years;
System.out.println(total3);
}
}5.常量和变量
1.常量
定义在程序运行期间固定不变的量
格式final 常量名 = 值；
final double PI = 3.1415926；
常量的分类
（1字符串常量凡是用双引号引起来的量如“ABC” "Hellow" "123"
（2整数常量无小数点的数字如1 -100 0
（3浮点型直接写上的数字有小数点如2.5 -3.14 0.0
（4字符常量凡是用单引号引起来的单个字符如‘A’ ‘b’ '1' '中'
（5布尔常量只有量中取值如 true false
（6空常量null 代表没有任何的数组
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
//字符型常量
System.out.println("kj10");
System.out.println("");//两个双引号之间的内容为空也有打印输出
System.out.println("ABC");
//整数常量（整数
System.out.println(-400);
System.out.println(0);
//浮点型（小数
System.out.println(3.14);
System.out.println(-0.25);
//字符常量
System.out.println('帅');
// System.out.println('AB');
// System.out.println('');//字符常量有且仅有一个字符不能有两个也不能为空
//布尔常量
System.out.println(true);
System.out.println(false);
//空常量
// System.out.println(null);//空常量不能直接打印输出
System.out.println();//或者什么都不写可以进行打印输出
}
}
2.变量
定义可以随时发生变化的量也是Java程序中最基本的储存单元其要素包括变量名变量类型和作用域。
注意点（1每个变量都有类型类可以是基本类型也可以是引用类型。
（2变量名必须是合法的标识符。
（3变量声明的是一个完整的语句所以每一个声明必须都要以分号结束。
（4修饰符不存在前后的顺序可以是 final static double PI = 3.1415926；也可以是 static final double PI = 3.1415926；
格式;数据类型 + 变量名 = 值；（可以用逗号隔开来来声明多个同类型的变量。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
//写法一:
//为了方便程序的可读性所以不建议这么写
int a=1,b=2,c=3;
//写法二（推荐写法
int d = 1;
int e = 2;
int f = 1;
}
}
3.变量的作用域
（1类变量写在类里面的变量加上satatic的关键字。
（2实例变量写在方法的外面类的里面（从属于对象或者理解为从属于这个类要通过这个类来使用它如果不规定初始值则利用的是初始值并且不需要进行初始化。
（3局部变量写在方法里面的变量（包括写在主程序里面的方法必须声明和初始化值。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
//类变量加上关键字static
//类变量是从水属于这个类的会随着这个类一起出来和消失。
static double saLary = 2500;
//实例变量写在方法的外面类得 里面。从属于对象或者是从属于这个类要通过这个类才能使用它可以不设置初始值
String name;
int age;
//主程序的方法或者是叫mian方法
public static void main (String[] args){
//局部变量是写在方法里面的只对这个方法负责跳出方法之外就不能被使用
//所有的局部变量必须声明和设置初始值
int i = 10;
System.out.println(i);
//使用面向对象的范畴
//左边的HelloWord为自定义类型helloWord为引用类型
//变量类型+变量名字=值为new 变量HelloWord（；将相当于拿到了自己也就是把自己给自己才能拿到自己的实例变量
//如果实例化对象不给初始值则会默认输出默认初始化的数值。
HelloWord helloWord= new HelloWord();
System.out.println(helloWord.name);
System.out.println(helloWord.age);
//类变量加上关键字static
//如果去点static则不会被调用
System.out.println(saLary);
}
//新写的一个增加的方法
public void add(){
//这里不能说输出变量i是因为局部变量不在add的方法里面。
System.out.println(i);
HelloWord helloWord= new HelloWord();
//这里的add方法可以调用实例变量是因为add方法在实例变量的作用域内
System.out.println(helloWord.name);
System.out.println(helloWord.age);
//这里的add方法也作用在类变量的作用域内所以可以调用类变量
System.out.println(saLary);
}
}
6.运算符
1.算数运算符
算数运算符+、-、*、/、%（取余
/**
* @Author代码贩子、 --南京邮电大学
*/
public class HelloWord {
public static void main (String[] args){
long a = 3000000000000000000L;
int b = 20;
double c = 3.14;
int d = 10;
//因为有double类型的所以输出为double类型
System.out.println(a+b+c+d);
//输出的为3000000000000000020明显超出了int类型因为有long类型这里发生了自动转换默认为龙类型
System.out.println(a+b);
}
}2.赋值运算符
赋值运算符=
赋值运算符=、+=、-+、*+、/=、%=
（1+= a +=3 相当于 a=a+3
（2-= a -=3 相当于 a=a-3
（3*= a *=3 相当于 a=a*3
（4/= a /=3 相当于 a=a/3
（5%= a %=3 相当于 a=a%3
注意事项只有变量才能使用赋值运算符
/**
* @Author代码贩子、 --南京邮电大学
*/
public class fx{
public static void main(String[] args){
int a=10;
a+=5;
System.out.println(a);//15
}
}3.关系运算符
关系运算符:>、<、>=、<=、==(相等)、!=(不等)
注意（1比较运算符的结果必须是个布尔型成了为ture不成立为false
（2如果进行多次判断不可以连着写 例如1<x<3
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args){
int a=10;
int b=20;
int c=20;
System.out.println(a>b);//false
System.out.println(a<b);//true
System.out.println(a>=b);//flase
System.out.println(a<=b);//true
System.out.println(a==b);//false
System.out.println(a!=b);//ture
System.out.println(b==c);//true
}
4.逻辑运算符
逻辑运算符&&(与)、||(或)、(非)
注意（1“&&和||”同时使用的时候会出现短路的情况如果左边已经得到了结果那么右面的将不再执行。
（2“&&和||”左右各需要一个布尔型。但是取反只需要一个布尔型即可。
（3“&&和||”如果有多个条件可以进行连写。
两个条件条件A&&条件B
三个条件条件A&&条件B&&条件C
对于1<x<3的情况写的时候应该拆成两个部分 然后用&&运算符连接起来。比如（1<x,&&x<3
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args){
System.out.println(true&&false);//false
System.out.println(true&&true);//true
System.out.println(3<5&&5<6);//true
System.out.println(true||true);//true
System.out.println(true&&false);//true
System.out.println(false&&false);//false
System.out.println(true);//true
System.out.println(!true);//false
//短路
int a=10;
System.out.println(3>4&&++a<20);//true 左边已经可以判断得到最终结果右边将不在执行
System.out.println(a);//10
int b=20;
System.out.println(3<4||++b<30);//true 左边已经可以判断得到最终结果右边将不在执行
System.out.println(b);//20
}
5.自增、自减运算符
++、--
基本含义让变量上升或者是下降一个为1的值。
注意在单独使用的时候++a和a--没有什么区别。
在混合使用的时候前++为先加后用。变量+1然后拿着加上的值继续使用。
后++为变量直接使用然后在加上1。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
int a = 10;
int b = ++a;
//如果不写++a那么输出的a的值为10；加上的话输出的值为11因为++a为先加后用。
System.out.println(a);//11
System.out.println(b);//11
int c = a++;
//先用后加
System.out.println(c);
}二Scanner与流程控制
1.Scanner用法
第一步导入sacnner类 import Java.until.*;(写在公共类的来头
第二步创建Scanner对象 Sacnner scanner=new Scanner（system.in);//构造Scanner类的对象sc,接收从控制台输入的信息
第三步打印输出提示符号 System.out.println（"提示文字；
第四步获取键盘输入的数据 String src=input.nextlnt()/nextLine();
第五步打印输出值System.out.println("打印输出的值为:");
第六步hasNext()/hasnextLine()来判断是否还有下一个输入。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
//new Scanner()为创建一个Scanner对象或者说是创建一个Scanner扫描器；
//System.in用来接收键入的数据
Scanner scanner = new Scanner(System.in);
//提示输入的数据
System.out.println("请输入数据");
//等待你所有的输出将字符串的额变量全部保存在变量中最后在通过下一句进行输出。
String src = scanner.next();
//用来提示输出数据
//这里在输出带有空格的字符串会出现空格之后的不输出因为next()不能得到带有空格的字符串。
System.out.println("您输出的数据为"+src);
//如果使用的是nextLine()来进行接收就可以获得空格之后的所有字符。因为nextLine()是以Enter为结束符nextLine()方法返回的是输入回车之前的所有字符。
String src2 = scanner.nextLine();
System.out.println("您输出的数据为"+src2);
//I/O流来进行关闭减少所占用的资源。
scanner.close();
} /**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
//new Scanner()为创建一个Scanner对象或者说是创建一个Scanner扫描器；
//System.in用来接收键入的数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据");
//if语句来进行是否还有数据的输入
//scanner.hasNext()看一下这个对象还有没有下一个。
if(scanner.hasNext()){
//通过scanner来接收用户的数据。
String src = scanner.nextLine();
//输入的内容为src的字符串
System.out.println("您输出的信息为"+src);
}
//I/O流关闭资源
scanner.close();
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
int a = 10;
float b = 3.14f;
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个整数");
if(scanner.hasNextInt()){
a = scanner.nextInt();
System.out.println("您输入的整数值为"+a);
}else{
System.out.println("您输入的不是整数");
}
System.out.println("请输入一个小数");
if(scanner.hasNextFloat()){
b = scanner.nextFloat();
System.out.println("您输入的小数值为"+b);
}else{
System.out.println("您输入的不是小数");
}
scanner.close();
}练习键入多个数字求输入数字的平均值以及总和。在输入数值的时候需要通过回车键来进行确认并且通过非数值来结束结束时输出对应的总和以及平均数的计算结果。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
//首先定义两个数值sum以及输入的次数。
double sum = 0;//定义初始值为0的总和sun
int m = 0;//定义输入的次数m
//创建扫描器
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个数");
//判断是否还有数据的输入
while (scanner.hasNextDouble()){
//输入一个随机数值
double x = scanner.nextDouble();
//输入了m+1次
m++;//m=m+1
//每次输入的数值相加最后赋值给sum
sum = sum+x;
System.out.println("你输入了"+m+"次数值当前的和为"+sum);
}
System.out.println("前"+m+"次的总和为"+sum);
System.out.println("输入"+m+"次之后的平均值为"+sum/m);
scanner.close();
}2.流程控制
1.顺序结构
定义Java的基本结构就是顺序结构除非特殊指明否则就按照顺序一步一步的执行。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args){
System.out.println("今天天气不错");
System.out.println("拿了十块钱");
System.out.println("去网吧打撸啊撸");
}3.if选择结构
1.单if语句
if(关系表达式<或者是布尔表达式>){
语句体（true就成立执行语句体false就绕过了语句体直接输出结束。；
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
//str.equals("hello"判断是否为真
if (str.equals("hello")){
System.out.println(str);
}
System.out.println("End");
scanner.close();
}2.标准语句
if（关系表达式{
语句体1；
}else{
语句体2；
}
注意如果关系表达式为ture则执行语句体1如果表达式为false则执行语句体2。
在执行的时候不能两个都执行也不能两个都不执行。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您要验证的成绩:");
double score = scanner.nextDouble();
if (score>=60){
System.out.println("您的成绩合格");
}else{
System.out.println("您的成绩不合格");
}
scanner.close();
}3.扩展语句
if（判断条件1{
语句体1；
}else if（判断条件2{
语句体2；
}
...........
else if（判断条件n{
语句体n；
}else{
语句体n+1；
}
注意如果满足条件一则下下面的将不再执行如果为false则执行语句体2、3、n。有一个满足的下面的将不再执行。
如果以上的都不满足将会无条件的执行else里的n+1的条件语句。
小练习输入指定的考试成绩判断考试的等级1.90-100 优秀；2.80-89 良；3.70-79 中；4.60-69 合格；5.0-59 差。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您要验证的成绩:");
double score = scanner.nextDouble();
if (score>=90&&score<=100){
System.out.println("您的成绩为优秀请保持状态");
} else if (score>=80&&score<=89){
System.out.println("您的成绩为良还有提升的空间");
} else if (score>=70&&score<=79){
System.out.println("您的成绩为中等你还可以更进一步");
} else if (score>=60&&score<=69){
System.out.println("您的成绩为合格请继续努力");
}else if (score>=0&&score<59){
System.out.println("您的成绩不合格请加倍努力");
}else{
System.out.println("您的输入有误请重新输入");
}
scanner.close();
}4.switch选择结构
1.break关键字
break关键字可以用在switch中一旦执行整个switch将立刻结束。
break关键字也可以用在其他语句中整个循环语句立刻结束打断循环。
2.default关键字
default的作用是在case匹配失败之后才会被执行打印出来相对应的输出信息。
3.continue关键字
contine关键字立即跳过本次的循环进入到下一个循环语句当中。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
char grade = 'c';
//switch匹配一个值比较方便
switch (grade){
case 'a':
System.out.println("优");
break;
case 'b':
System.out.println("良");
break;
//break在整个语句中一旦被执行将会结束整个循环。
//如果不加break将会出现贯穿的现象。
//c和d如果不加break将会打印输出“中”后面的所有的输出字符。
case 'c':
System.out.println("中");
break;
case 'd':
System.out.println("差");
break;
//default的作用是在case匹配失败之后才会被执行打印出来相对应的输出信息。
default:
System.out.println("您的输入有误");
}
}5.循环结构
| 循环结构表 | |||
| 顺序上 | 应用上 | 格式 | |
| For循环 | 先判断。在执行。 | 循环次数确定通常用for循环。 | for（初始化表达式；条件判断；步进语句{ 循环体 } |
| While循环 | 先判断。在执行。 | 循环次数不确定通常用whiler循环。 | 初始表达式； While（条件判断{ 循环体 步进语句 } |
| Do whlle循环 | 先执行在判断 | 循环次数不确定通常用whiler循环。 | 初始表达式； Do{ 循环体 步进语句 }while（条件判断； |
1.while循环
在进行执行的时候首先对条件语句进行判断才进行执行在循环次数不确定的时候通常使用while循环语句。
初始表达式；
while（条件判断{
循环语句；
步进语句；
}
小练习使用whlle循环语句来计算1+2+3+……+100的和。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
int i = 0;
int sum = 0;
while (i<=100){
sum = sum + i;
i++;
System.out.println("此时运行了" + i+"次" + "此时的和为"+sum);
}
System.out.println("和为" +sum);
}2.do while循环
在执行的时候首先执行才能进行判断即使不能满足条件也至少执行一次。循环次数不确定通常用whiler循环。
初始语句；
do{
循环体；
步进语句；
}while（条件判断表达式；
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
int i = 0;
int sum = 0;
do {
sum = sum + i;
i++;
System.out.println("此时运行了" + i+"次" + "此时的和为"+sum);
} while (i<=100);
System.out.println("和为" +sum);
}3.for循环（重点
在执行的时候先进性判断然后在执行在执行的时候循环次数确定。
for（初始值；条件表达式；步进语句{
循环体1；
}else{
循环体2；
}
小练习1求100以内（包括100的奇数偶数的和以及总体的和。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
int sum1 = 0;
int sum2 = 0;
for (int i = 0; i <=100 ; i++) {
if (i%2!=0){
sum1+=i;
}else{
sum2+=i;
}
System.out.println("此时的和为"+sum1);
System.out.println("此时的和为"+sum2);
}
System.out.println("此时的和为"+sum1+sum2);
}小练习2用for循环输出1-1000以内（包含1000内所有可以被5整除的数并且每一行只打印三个。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
for (int i = 0; i <=1000 ; i++) {
//这里说明是可以被5整除的数我们把它输出出来
if (i%5==0){
System.out.print("您得到的数为"+i+"\t");
}
//如果i模5*3。那么就是先换行
if (i%(5*3)==0){
System.out.print("您得到的数为"+"\n");
}
}
}3.小练习打印等腰三角形
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
for (int i = 1; i <= 5; i++) {
for(int j = 5;j >= 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();
}
}4.小练习利用for循环打印九九乘法表。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
//3.加入for循环之后将常量1都替换成变量j。下面需要去掉重读的项目。找一下是哪里写死的原因
//4.此时发现缺2*9 3*9 4*9......
//5.此时只要减少重复项即可我们发现j是不变的只有i<j的时候才能满足
for (int j =1;j<=9;j++){
//1.先打印第一列
for (int i = 1; i <=j; i++) {
//2.输出成1*i的形式此时应该考虑怎么解决2* 3*的问题如果解决的话需要将常量1改成变量的形式在佳茹一个for循环
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
//每输出一行进行换行
System.out.println( );
}
}4. 增强for
主要用来遍历数组和集合的。
for（声明语句表达式{
代码句子；
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
int[] i ={10,20,30,40,50};
//上下相等这里是数组部分目前可以不做讨论。
for(int x =0;x<5;x++){
System.out.println(i[x]);
}
//数组每一项遍历出来赋值给int xx指的就是每一个数值
for (int x:i){
System.out.println(x);
}
}三方法的定义和调用
1.方法的定义方法包括一个方法的开头和一个方法体。
修饰符 返回值类型 方法名（参数类型 参数名{
方法体；
return 返回值；
}
解释
修饰符可以有 public static final等
返回值类型如果为void则返回为空也就是不需要rutern如果是int等类型需要进行返回
方法名可以根据命名的规则来自己进行定义比如增加的add方法和删除的del方法。
参数类型包括两种一个形式参数和一个实际参数。参数像是一个占位符可以被选择也可以不做选择（也就是方法可以 不含参数。
***形式参数指的是在方法被调用时来接收外界输入的数据。
***实际参数指的是调用方法实际传给对方的参数。
方法体包括定义的具体语句以及定义该方法的功能。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
//直接调用方法给个实际参数1和2。
/*
上面的参数1和2传输给下面的a和b经过reyurn传给sum进行输出。
也就是通过这个语句来调用这个方法。
*/
int sum = add(1,2);
System.out.println(sum);
}
//写一个add的方法给个形式参数a和b想要被main方法调用需要用修饰符static改成类方法
//这里的加法需要定义函数使用形参的形式
public static int add (int a,int b) {
//返回一个值如果是void则不需要进行返回如果是int等则需要进行返回并且一一的对应。
return a + b;
}2.方法的调用
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
//这里的maxmin作为有参的结果赋给max这个值在进行打印输出。
int max =maxmin(30,30);
//这里的方法没有返回值只用来传递参数来进行输出。
System.out.println(max);
}
public static int maxmin(int a,int b){
int result=0;
if(a==b){
System.out.println("a=b");
return 0;//终止方法
}
if (a>b){
result=a;
}else{
result=b;
}
return result;
}例如int max =maxmin(30,30);
如果方法为void方法的调用一定是一条语句。
例如System.out.println("Hello word");
小练习调用方法打印正三角形。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args){
test();
}
public static void test(){
for (int i = 1; i <= 5; i++) {
for(int j = 5;j >= 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();
}
}2.方法重载
简单的说就是方法名称相同方法里面包含的参数类型不同。
方法重载的规则
1.方法名必须相同。
2.参数名称必须不同。（个数不同类型不同排列顺序不同等。
3.方法的返回值可以相同也可以不同。
4.仅仅是返回值类型不同则不可以完成方法的重载。
实现理论方法名称相同的时候编译器会根据方法参数类型的个数参数类型去逐个匹配以选择对应的方法如果匹配失败编译器会报错。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
//这里的maxmin作为有参的结果赋给max这个值在进行打印输出。
double max =maxmin(30.0,20.0);
//这里的方法没有返回值只用来传递参数来进行输出。
System.out.println(max);
}
public static double maxmin(double a,double b){
int result=0;
if(a==b){
System.out.println("a=b");
return 0;//终止方法
}
if (a>b){
//这里从高到低需要进行强转
result=(int) a;
}else{
result=(int) b;
}
return result;
}
public static int maxmin(int a,int b){
int result=0;
if(a==b){
System.out.println("a=b");
return 0;//终止方法
}
if (a>b){
result=a;
}else{
result=b;
}
return result;
}四数组
1.维数组
1.数组的定义
1.数组是一个容器可以用来存放多个数组。
2.数组的特点
数组是一种引用类型。
数组中存在的多个数据的类型必须是统一的。
数组的长度在运行中是不可以改变的。
2.动态和静态数组
静态数组
在创建的额时候不指定其长度直接指定内容。
格式 数据类型[ ] 数组名字 = new 数据类型[ ]{元素1元素2元素3......}；
数据类型[ ] 数据名称 = {元素1元素2元素3......}；
注意事项虽然静态数组没有指出其长度但是我们可以根据内容来计算出长度。
静态数组的创建过程可以拆分为两个步骤如果携程省略的格式那么就不可以拆分成两个步骤。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
//直接创建一个数组里面全是int数字
int[] arr1 = new int[]{10,20,30,40,50};
int[] arr2 = {10,20,30,40,50};
//拆分写
int[] arr3;
arr3=new int[4];
int[] arr4;
arr4= new int[]{10,20,30,40,50};
}动态数组
动态数组在进行创建的时候直接指定数据的长度。
格式数据类型[ ] 数组名称 = new 数据类型[数组长度]；
解释含义
左边的数据类型数组当中保存的数据类型全都是统一的数据类型
左边的[ ]:代表的是一个数组
数组名称我们定义的数组名称
new ；代表的是创建数组的动作。
右边的数据类型必须和左边的数据类型是相统一的
右边的[ ] :也就是数组上可以保存多少个数据为一个int数字。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
//声明一个可以保存300个int的数据的数组。
int[] arr1 = new int[300];
double[] b=new double[300];//创建一个数组可以存放300个double数据
String[] c=new String[5];//创建一个数组可以存放300个String数据
}3.数组的打印输出
如果直接打印数组的名字则输出的是数组在内存地址中对应的哈希值。如果想要出现数据应该是数组名字+[索引值]（索引值是int数字代表的是数组当中元素的编号。（索引值是从0开始的一直到数组的长度-1为止
使用动态初始化数组的时候其中的元素都会存在一个默认值其默认规则如下所示
（静态初始化也有默认值的过程只不过系统自动马上将默认值替换为了大括号当中的具体数值
| 默认规则 | |||||
| 整型 | 浮点型 | 字符型 | 布尔型 | 引用类型 | |
| 默认类型 | 0 | 0.0 | \u0000 | false | null |
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
//静态初始化创建+赋值
int[] a ={1,2,3,4,5};
System.out.println(a[0]);
//动态初始化包含默认初始化
int[] b = new int[10];
b[0]=10;
b[1]=10;
System.out.println(b[0]);
System.out.println(b[1]);
//这里输出的是0
System.out.println(b[2]);
//这里输出的是0
System.out.println(b[3]);
}4. Java内存
在Java的内存机制里面存在栈、堆和方法区。我们在声明数组的时候比如int[ ] array = null;此时的堆中是空的但是在栈中会压入一个array。我们声明的数组是一个空的这个名字并没有一个实际的作用。我们在创建数组的时候（array = new int[10];,我们new关键词的东西都会放在堆里面。 在做完这一步的时候array在堆里面就开辟了一个空间这个空间里面开辟的是初始的大小为10并且都是我们定义的int类型的。我们的对象也就是存在于这个地方的。第三步在给数组元素赋值的时候里面才有值如果没有赋值的时候里面则是一个默认值如果是输出第十一个数值的时候会出现一个错误java.lang.ArrayIndexOutOfBoundsException: 10也就是数组下标越界的情况。 （出现数组下标越界的情况可能是个这个数值不存在或者是不再这个开辟的数组对象的范围内等所以就出现了拿不到的情况从而出现了下标越界的bug。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
//静态初始化创建+赋值
int[] a ={1,2,3,4,5};
System.out.println(a[0]);
//动态初始化包含默认初始化
int[] b = new int[10];
b[0]=10;
b[1]=10;
System.out.println(b[0]);
System.out.println(b[1]);
//这里输出的是0
System.out.println(b[2]);
//这里输出的是0
System.out.println(b[3]);
//数组的下标越界出现了新的bug（java.lang.ArrayIndexOutOfBoundsException: 10
System.out.println(b[10]);
}4.数组的使用
1.for each（增强for
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
int[] arrays = {1,2,3,4,5};
//arrays代表的是一个数组nt array代表的是每个数组里面的每一个元素,但是取不到下标。
for (int array: arrays){
System.out.println(array);
}
}2.数组做方法入参
数组可以封装成一些参数一半在里面调用它进行操作即可。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
int[] arrays = {1,2,3,4,5};
test(arrays);
}
public static Void test(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
return null;
}3.数组做返回值
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
int[] arrays = {1,2,3,4,5};
/*
调用reverse方法将arrays传进来这样会返回一个结果int[] reverse 这个显示的就是已经被反转过的数组。
*/
int[] reverse = reverse(arrays);
test(reverse);
}
public static int[] reverse(int [] arrays){
/*反转的话可以考虑将第一个赋值给最后一个
int[arrays.length]是保证进来的数组和返回的是一个结果
int[] result = new int[arrays.length];
*/
int[] result = new int[arrays.length];
/*
for (int i = 0; i < ; i++) 将我们结果里面的每一个值从我们传入的arrays拿出来
因此我们可以用result【】 = arrays【i】来进行就是将传入的i个元素传入到result的元素
我们需要j=result.leatch-1；j--
* */
for (int i = 0, j=result.length-1;i <arrays.length ; i++, j--) {
//将传进来的第一个i元素传给我们附近来的最后一个元素j
result[j] = arrays[i];
}
return result;
}
public static Void test(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.println(arrays[i]);
}
return null;
}小练习取数组的最大最小值以及求和。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
int[] arrays = {1,2,3,4,5};
int max = arrays[0];
for (int i = 1; i <arrays.length ; i++) {
if (max<arrays.length){
max = arrays[i];
}
}
System.out.println("此时最大的值为"+max);
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
int[] arrays = {1,2,3,4,5};
int max = arrays[0];
for (int i = 1; i <arrays.length ; i++) {
if (max>arrays.length){
max = arrays[i];
}
}
System.out.println("此时最小的值为"+max);
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
int[] arrays = {1,2,3,4,5};
int sum = 0;
for (int i = 0; i <arrays.length ; i++) {
sum+=arrays[i];
}
System.out.println("此时和的值为"+sum);
}2.二维数组
二维数组相当于在数组里面有嵌套了一个数组。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
/*
相当于是一个五行两列的数
{12} 代表的是arrays[0]存放的是数值1和2
*/
//这行数组代表的是长度为5的二维数组
int[] [] arrays = {{1,2},{2,3},{3,4},{4,5},{5,6}};
//此时打印的是数组的地址值
//System.out.println(arrays[0]);
//取出的是二维数组中下标为0数组中的一维数组中的元素的所有值
test(arrays[0]);
//取出的是二维数组中下标为0数组中的一维数组中的下标为1的元素的值
System.out.println(arrays[0][1]);
//取出的是二维数组中的长度
System.out.println(arrays.length);
//打印所有数值
for (int i = 0; i <arrays.length ; i++) {
for (int j = 0; j <arrays[i].length ; j++) {
System.out.println(arrays[i][j]);
}
}
}
public static void test(int[] arrays){
for (int i = 0; i <arrays.length ; i++) {
System.out.println(arrays[i]);
}
}3.冒泡排序法（江湖中人尽皆知
两层循环外层冒泡轮数内层一次比较江湖中人尽皆知。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main (String[] args) {
int[] a ={55,4564,22,1,0,56456,41234564,41654321};
//调用完我们自己写的排序方法以后返回一个排序后的数组
int[] test= test(a);
System.out.println(Arrays.toString(test));
}
/*
冒泡排序
1.比较数组中两个相邻的元素如果第一个比第二个大就交换这两个数之间的顺序。
2.每一次比较都会产生一个最大的数或者是最小的数。
3.下一轮则可以少一轮排序。
4.一次循环直到结束。
*/
public static int[] test(int[] arrays){
int temp = 0;
//外层循环判断我们要走多少次
for (int i = 0; i <arrays.length-1 ; i++) {
//通过标识为减少不必要的循环
boolean flag = false;
//内层循环比较数组中两个相邻的元素如果第一个比第二个大就交换这两个数之间的顺序。
for (int j = 0; j < arrays.length-1; j++) {
//arrays[j+1]>arrays[j]表示如果后一个数大于当前这个数就要进行交换
if (arrays[j+1]>arrays[j]){
//需要建立临时变量进行三变量倒手
temp = arrays[j];
arrays[j]= arrays[j+1];
arrays[j+1]=temp;
flag = true;
}
}
if (flag=false){
break;
}
}
return arrays;
}五什么是面向对象
“面向对象的方法主要是把事物给对象化包括其属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程面向过程抽象成类然后封装方便使用就是面向对象（万物皆对象。
其本质就是以类的方式组织代码以对象的组织（封装数据。
六类与对象的关系
1.什么是类
什么是类类是一种抽象的数据类型他是对某一类事物的整体描述/定义但是并不代表某一具体的事物。例如手机电脑等等；又比如Person类、Pet类、Cat类等等。
2.什么是对象
什么是对象对象是抽象的具体实例。比如张三是人的一个具体实例旺财是一个狗的具体实例。
能够体现出特点展现出功能的具体实例而不是一个抽象的概念。
3.创建与初始化对象
1.什么是类
1.使用new关键字创建对象除了分配内存空间以外还会个创建好的对象进行默认初始化以及对类中的构造器进行调用。
2.通常情况下一个类能不能直接使用需要根据一个类创建一个对象才能使用因此我们需要创建一个对象来调用这个类。
创建类的步骤
1导包
格式import包名称.类名称;
对于同一个包的情况下可以省略导包语句
2创建
格式
类名称 对象名=new 类名称（;
3使用
（1成员属性
格式 对象名.成员变量名；、
（2成员方法
格式: 对象名.成员方法名（参数;
定义一个标准类（包括如下四个部分
（1 所有的成员变量都用private修饰、
（2 每个成员变量都有getxxx()detxxx()方法
（3 有一个无参构造
（4 有一个全参构造
/**
* @Author代码贩子、 --南京邮电大学
*/
//一个项目只存在一个main方法
public static void main(String[] args) {
/*类抽象的、需要实例化
类实例化后会返回一个自己的对象
students对象就是Students的一个具体实例
*/
Students students= new Students();
students.name = "张三";
students.age=20;
System.out.println(students.name+students.age);
}
//属性
String name;
int age;
//方法
void stu(){
//this代表这个类 指向型
System.out.println(this.name+"学生在学习");
}2.什么是构造器
类中的构造器也叫构造方法在进行创建对象的时候必须进行调用。并且每一个类中都隐藏一个无参构造。
格式public 类名称（形参 实参{
方法体
}
构造器
1.和类名必须相同
2.没有返回值
作用
1.new的本质就是在调用构造方法
2.初始化对象的值
注意点
定义有参构造之后如果还想用无参构造的话那么就必须显示的定义一个无参构造。
/**
* @Author代码贩子、 --南京邮电大学
*/
//一个项目只存在一个main方法
public static void main(String[] args) {
Students students= new Students("代码贩子");
System.out.println(students.name);
}
String name;
//一个类及时什么也不写也会存在一个方法
//定义一个构造器
//实例化初始值
/*
使用new关键字必须使用构造器
用来初始化值
*/
//无参构造
public Students(){
//代表的是上面的name
this.name = "张三";
}
//有参构造
//一旦定义了有参构造无参构造必须显示定义
public Students(String name){
this.name = name;
}
//alt+inset可以快速构造3.创建对象内存分析
1.首先先在方法区把Demo01类的游戏额代码信息放进来。
2.主方法main（会被压入栈.。
3.一旦new会在方法区加载出Student这个类。
4.当等于通过Students A= new Students();生成一个A同学放入栈中（此时的A只是一个引用或者变量名。
5.针对于这个对象A会在堆里面通过这个模板new了一个A。
6.此时的action（方法其实调用了方法区中的action（方法此时Students A= new Students();方法就完成了。
7.接下来给name、age进行赋值。
8.将方法区的Demo01中的常量池中的值丢个堆中A进行name和age的赋值此时A.name = "代码贩子、"; A.age = 24;以及A.action();中的值就赋完了此时这个对象A的堆中就有这些值了此时就可以使用它了。
9.如果出现了同学B就相当于当等于通过Students A= new Students();生成一个A同学放入栈中（此时的A只是一个引用或者变量名。
10.针对于这个对象A会在堆里面通过这个模板new了一个B。
11.此时的action（方法其实调用了方法区中的action（方法此时Students。 B= new Students();方法就完成了此时后面的操作相同。
注意静态方法区所有带static关键字的东西一开始就在这个地方和类一起加载的类一加加载它就加载了。所有的对象都可以加载它。
/**
* @Author代码贩子、 --南京邮电大学
*/
//一个项目只存在一个main方法
public static void main(String[] args) {
Students A= new Students();
A.name = "代码贩子、";
A.age = 24;
System.out.println(A.name+A.age+A);
A.action();
}
public String name;
public int age;
//无参构造
void action(){
System.out.println("疯狂学习Java编程知识");
}七封装、继承、多态
1.封装
定义（自己理解该露的露该藏的藏。将一些较为复杂的内部结构进行隐藏将一些简单的（比如接口该暴露给用户的东西暴露出来比如电视机的外观等等。大部分程序的细节都应该藏起来。我们设计的程序应该追求”高内聚低耦合“（也就是系统内部的数据操作应该由自己完成不允许外部进行干预；仅仅暴露少量的方法给外部来进行使用。
一旦使用了private进行修饰本类当中可以随意访问但是超出了本类就不可以访问了。
间接访问private成员变量就定义一对getxxx（setxxx（方法
对于set来说不能有返回值参数类型和成员变量对应
对于get来说不能有参数必须有返回值类型并且返回值类型与成员变量对应。
封装的意义
1.提高程序的安全性保护数据。
2.隐藏代码的关键细节（以s1.setAge(24)来说用户根本不知道里面干了什么只有我们程序员才知道;。
3.统一接口。
4.提高了系统的可维护性。
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
Students s1 = new Students();
/*
s1.name;无法进行调用变量被private被私有了
如果换成public公有的关键字才可以被调用
*/
s1.setName("代码贩子、");
s1.setAge(24);
s1.setSex('男');
System.out.println(s1.getName());
System.out.println(s1.getAge());
System.out.println(s1.getSex());
}
//private关键字为私有化
private String name;//名字
private int age;//年龄
private char sex;//性别
/*
想要解决主程序中的s1.name被调用的问题就需要提供一些可以操作这个属性的方法
解决办法就是提供一些public的get、set方法
*/
//获得这个数据
public String getName(){
return this.name;
}
//给这个数据设置值
public void setName(String name){
this.name=name;
}
//快捷键
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<100&&age>0) {
this.age = age;
}else {
this.age=3;
}
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}2.继承
定义继承的本质就是对某一批类进行的抽象从而实现对现实世界最好的建模。
关键字extends。意思为”扩展“子类是父类的扩展。
修饰符的级别;public>protected>default（或者是不写>private
Java中的类只有单继承的关系没有双继承的关系（相当于一个父类可以有多个子类但是多个子类只能以有一个父类。
| 级别（由大到小 | ||||
| 关键字名称 | Public | protected | default | private |
| 作用域 | 可以被该类的和非该类的任何成员访问 | 子类可以使用父类中其他的不可以它相当于传递给子类的一种继承的东西。 | 一个包内可以访问如果不在一个包内即使是继承关系子类也无法访问。 | 只有该类可以直接调用其余类想要调用需要使用get（set（方法 |
继承是类和类之间的一种关系除此之外类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类一个为子类（派生类一个为父类（基类。子类继承父类用关键字extends来表示。
子类和父类之间从意义上讲应该具有”is a“的关系。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
Student student =new Student();
//子类可以继承父类的所有方法
/*
父亲说我有钱了
儿子继承了父亲的财产
儿子也说我有钱了
*/
//子类没有任何的说明
//接收这个方法
student.money();
//子类可以继承父类的所有属性
//父类中父亲姓代码那么子类中的儿子也会继承叫代码
System.out.println("我跟随父亲的姓氏姓"+student.xingshi);
/*
父类中的父亲有十个小妾但是用private关键字进行私有了只属于父类自己
儿子不管是出于道德还是出于代码逻辑都不能进行继承
System.out.println(student.xiaoqie);
因此子类无法进行继承和调用
*/
/*
出于道德不继承父亲的小妾但是父亲有十件古董但是被父亲私有制了那么我们要想获得必须经过父亲的同意
让父类提供一些public的get、set方法
*/
System.out.println("父亲同意将私有的古董给我"+student.getGudong()+"件");
}
}
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
Student student =new Student();
//子类可以继承父类的所有方法
/*
父亲说我有钱了
儿子继承了父亲的财产
儿子也说我有钱了
*/
//子类没有任何的说明
//接收这个方法
student.money();
//子类可以继承父类的所有属性
//父类中父亲姓代码那么子类中的儿子也会继承叫代码
System.out.println("我跟随父亲的姓氏姓"+student.xingshi);
/*
父类中的父亲有十个小妾但是用private关键字进行私有了只属于父类自己
儿子不管是出于道德还是出于代码逻辑都不能进行继承
System.out.println(student.xiaoqie);
因此子类无法进行继承和调用
*/
/*
出于道德不继承父亲的小妾但是父亲有十件古董但是被父亲私有制了那么我们要想获得必须经过父亲的同意
让父类提供一些public的get、set方法
*/
System.out.println("父亲同意将私有的古董给我"+student.getGudong()+"件");
}
}
//学生（派生类；Person的子类继承了人的所有关系
public class Student extends Person {
}
//教师（派生类；Person的子类继承了人的所有关系
public class Teacher extends Person {
}
3.this和super关键字
supper代表队的是在子类中调用父类中的属性或者是方法。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
Student student = new Student();
student.name("代码贩子本人");
}
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public class Person extends Object {
protected String name = "代码贩子、";
}
public class Student extends Person {
private String name = "小代码贩子、";
void name(String name){
System.out.println(name);//代表的是方法传进来的String name
System.out.println(this.name);//代表的是private私有制的name
System.out.println(super.name);//代表的是父类protected受保护的name
}
}public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
Student student = new Student();
}
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public class Person extends Object {
public void say(){
System.out.println("我是父亲");
}
}
public class Student extends Person {
public void say(){
System.out.println("xusheng");
}
public void test(){
say();
this.say();
super.say();
}
}
如果父类的构造器换成私有制的关键字属性那么原本的子类就无法使用super关键字来进行方法的调用。
这里参杂了一个代码位置的问题。
首先在我们的子类以及父类都会隐藏一个默认的无参构造器。相当于在Person类中有个public Person() { System.out.println("父类无参执行了"); }在子类中有个public Student() { System.out.println("子类有参执行了"); }。此时在new Studengt（；的时候执行的结果如下所示
因为在子类中调用子类的构造器之前还隐藏了一段代码 super()。
super();的代码只能放在子类构造器第一行如果和System.out.println("子类有参执行了");互换位置就会报错。因为new Studengt（；的同时将父类的也new了。
this关键字也是如此急啊如在子类中急啊如一个有参构造器public Student(String name) { this.name = name; }此时调用的时候this("代码贩子、");也只能放在无参构造器的额第一行。此时苏果想要放super关键字也必须放第一行this关键字就会报错。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
Student student = new Student();
}
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public class Person extends Object {
//走一个无参构造器
public Person() {
System.out.println("父类无参执行了");
}
void say(){
System.out.println("我是父亲");
}
}
public class Student extends Person {
private String name;
public void say(){
System.out.println("xusheng");
}
public Student() {
/*
在调用构造器的时候要么调用父类要么调用子类必须保证在构造器的第一个
正常情况下super();不写也是正常的会默认的调用无参。
*/
this("代码贩子、");//调用本类有参构造器必须放在子类的第一行。
//super();//调用父类无参构造器必须放在子类的第一行。（隐藏
System.out.println("子类有参执行了");
}
public Student(String name) {
this.name = name;
}
public void test(){
say();
this.say();
}
}假如父类中的无参构造我们不写只写了有参构造那么在子类中就无法进行父类无参构造的调用不仅如此子类中的无参也会报错。南无说我就想要调用父类中的有参构造那么就需要在子类无参构造中利用super("代码贩子、");的形式一步步的调用。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
Student student = new Student();
}
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public class Person extends Object {
public String name;
//走一个有参构造器
public Person(String name) {
this.name = name;
}
void say(){
System.out.println("我是父亲");
}
}
public class Student extends Person {
private String name;
public void say(){
System.out.println("xusheng");
}
public Student(){
super("代码贩子、");
}
public void test(){
say();
this.say();
}
}
因此我们封装的时候无论一个类怎么写在写的时候一般只要重写了有参构造一般都会加上无参构造。
super注意点
1.super是调用父类的构造方法必须写在构造方法的第一个。
2.super必须只能出现在子类的方法或者3.构造方法中。
3.this和super不能同时调用构造方法。
VS this注意点
1.代表的是本身调用者这个对象。
2.代表父类对象的应用。
前提
2.没有继承的前提下也可以使用。
3.只能在继承条件下才可以使用。
构造方法
this（；调用的是本类的构造。
super（；调用的是父类的构造。
4.方法重写
静态方法
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
/*
方法的调用只和定义的数据类型有关
*/
A a = new A();
a.test();//走的是A类的静态方法
B b = new A();//父类的引用可以指向子类
b.test();//走的是B类的静态方法
}
}
//A类继承了B类
public class A extends B {
public static void test(){
System.out.println("A=>test()");
}
}
//重写都是方法的重写和属性无关
public class B {
public static void test(){
System.out.println("B=>test()");
}
}
非静态方法
此时把A和B中的静态方法去掉利用快捷键在A类中进行重写默认走的都是B的方法。如果在A类中重写自己的方法得到的都是A的方法。所以可以得出一个结论就是静态方法和非静态方法有区别。
原因是B b = new A();//非静态方法中子类重写了父类的方法。此时才叫重写
并且重写的时候修饰符还必须是public的不能是私有的。
只有子类继承了父类才能重写并且是子类重写父类的方法。
public class A extends B {
@Override
public void test() {
super.test();
}
}
//重写都是方法的重写和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
public class A extends B {
@Override
public void test() {
System.out.println("A=>test()");
}
}
//重写都是方法的重写和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
总结（重写
1.必须有继承到关系并且还是子类重写父类的方法和属性无关。
特点
1.方法名必须相同。
2.参数列表必须相同。
3.修饰符范围可以扩大。
4.抛出的异常可以被缩小但是不能扩大。
总结子类的方法和父类必须要一致方法体不同。
为什么需要重写？
父类的功能子类可能不一定需要或者是不一定满足
5.多态
定义同一个方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的但可以指向对象的引用类型很多。
多态可以让程序变得更灵活。
一个对象的实际类型是确定的比如new Student()new Person();但是可以指向这个类型的引用类可以是任意的。比如Person s2 = new Student(); Object s3 = new Student()。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
/*
一个对象的实际引用类型是确定的比如
new Student()
new Person()
*/
Student s1 = new Student();//子类指向的引用
/*
子类能调用的方法都是自己的或者是父类的
*/
//父类的引用可以指向子类（有父子关系就可以 比如用String肯定不行因为没有指定的关系。
Person s2 = new Student();//父类指向的引用
/*
父类型虽然可以指向子类但是不能调用子类独有的方法
*/
Object s3 = new Student();
s2.run();//运行结果为run因为子类重写了父类的方法执行的为子类的方法
s1.run();
s1.eat();
//对象能执行哪些方法主要看对象左边的类型和右边的关系不大。
/*
((Student)s2).eat();
强制转换后可以进行调用
*/
(s2.eat());//无法调用是因为 Person s2 = new Student();虽然new了Student()但不能使用Student()方法要看Person里面有没有有的话才能用。
// 子类重写了父类的方法执行的为子类的方法。子类和父类的方法都有的话子类没有重写方法就调用父类的如果重写的话就带哦用子类的。
}
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public class Person extends Object {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
注意事项
1.首先多态是方法的多态跟属性无关。
2.要有关系（父子类不然的话会出现类型转换异常。
存在条件
1.要有继承的关系。
2.方法需要重写（static属于类不属于实例、final输入常量在常量池private私有的不能重写就不能进行多态。（假如子父类都有run方法那么子类没有重写方法就调用父类的如果重写的话就带哦用子类的。
3.父类引用指向子类对象、
6.instanceof关键字
作用instanceof关键字可以判断两个类之间是否存在父子关系。
1.父类引用指向子类的对象。
2.子类转换为父类（向上转型不用强制转换。
3.父类转换为子类（向下转型强制转换后会丢失方法。
4.方便方法的调用减少重复的代码提升代码的利用率并且使代码变得更简洁。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
//Object>String
//Object>Person>Student
//Object>Person>Teacher
//System.out.println(A instanceof B);
//A和B是否有继承关系
Object object = new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
Person person = new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
//System.out.println(person instanceof String);//编译错误
}
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public class Person extends Object {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
Person student = new Student();
//因为这里是Person类型的student
//student.eat();
//将Person类型的student的对象转换成student类型我们就可以使用student类型的方法了。
Student obj = (Student) student;
//这样就可以使用低一层的方法了
obj.eat();
//第二种写法（（studentobj.eat();
/*
由低转高（子类转换成父类
可能会丢失一些方法
*/
Person person = new Student();
//丢失一些方法
//person.eat();
}
}
/**
* @Author代码贩子、 --南京邮电大学
*/
public class Person extends Object {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
7.static关键字
1.static静态变量在类中是共享的。
2.非静态方法可以访问本类中的所有静态方法。
3.静态方法可以调用本类中所有的静态方法。
原因因为静态的方法是和mian方法一起加载出来的加载之前还没有普通的方法所以就无法调用。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
/*
static静态变量在类中是共享的
*/
private static int name;//静态变量
private double age;//非静态变量
public static void main(String[] args) {
System.out.println(name);//直接可以调用
System.out.println(age);//不可以直接调用
Demo01 demo01 = new Demo01();
//通过对象调用
System.out.println(demo01.age);
System.out.println(demo01.name);
}
}
1.静态代码块(最早的执行)；静态代码块只在一开始执行一次并且后面将不再执行。
2.匿名代码块在对象一创建的时候就先走匿名代码块然后再走构造器；作用赋初始值。
3.构造器最后执行。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
{
//匿名代码块
//作用赋初始值
System.out.println("匿名代码块");
}
static {
//静态代码块(最早的执行)
System.out.println("静态代码块");
}
public Demo01(){
//构造器（最后执行
System.out.println("构造器");
}
public static void main(String[] args) {
Demo01 demo01 = new Demo01();
System.out.println("-------------分隔符-------------");
/*
因为静态代码块只执行一次
对象一创建的时候就先走匿名代码块然后再走构造器
静态代码块只在一开始执行一次并且后面将不再执行
*/
Demo01 demo02 = new Demo01();//此时执行的时候静态代码块就没了
}
}
8.抽象类
抽象类定义;在普通类的结构里面增加抽象方法的组成部分。
抽象方法定义是指没有方法体的方法。
关键字为abstract。
注意
1.不能new这个抽象类只能靠它的子类进行实现。
2.抽象类中可以写普通的方法。
3.抽象方法必须在抽象类中。
/**
* @Author代码贩子、 --南京邮电大学
*/
//抽象类
public abstract class Person {
//约束 有人帮我们实现
//只有方法的名字没有方法的实现
public abstract void work();
}
//抽象类的所有方法继承了它的子类都必须要实现它的方法除非子类本身也是一个抽象类。
public class Student extends Person{
@Override
public void work() {
}
}
9.接口
接口的定义简单来说为某种特征的约定。
关键字interface。
1.类可以实现接口 implements
2.实现了接口的类就需要重写接口中的方法
3.利用接口实现多继承但是与继承关系无关。
//接口定义的关键字interface
//接口都需要有实现类
public interface userService {
//接口中的所有定义都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
public interface timeService {
void timer();
}
//类可以实现接口 implements
//实现了接口的类就需要重写接口中的方法
//利用接口实现多继承
public class userServiceImpl implements userService,timeService{
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
总结
1.约束。
2.定义一些方法让不同的人实现功能。
3.接口不能被实例化并且接口没有构造方法。
4.implements关键字可以实现多个接口。
5.必须要重写接口中的方法。
10.内部类
定义将一个类定义在一个类或者一个方法里面这样的类称着内部类。
注意一个Java文件中可以有多个class类但是只能有一个public class类。
1.成员内部类
定义成员内部类是最普通的一种内部类成员内部类可以访问外部类所有的属性和方法。但是外部类要访问成员内部类的属性和方法必须要先实例化成员内部类。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
A a = new A();
a.out();
//通过这个外部类来实例化内部类
A.Inner inner = a.new Inner();
inner.in();
inner.getoutId();
}
}
public class A {
private int id = 10;
public void out(){
System.out.println("这是一个外部类");
}
public class Inner{
public void in(){
System.out.println("这是一个内部类");
}
//内部类可以获得外部类的私有属性以及方法
public void getoutId(){
System.out.println(id);
}
}
}
2.静态内部类
定义静态内部类就是在成员内部类多加了一个 static 关键字。静态内部类只能访问外部类的静态成员变量和方法（包括私有静态
import A.Inner;
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
A a = new A();
a.out();
//通过这个外部类来实例化内部类
Inner inner = new Inner();
inner.getoutId();
// A.Inner inner = a.new Inner();
// inner.in();
// inner.getoutId();
}
}
public class A {
private static int id = 10;
public void out(){
System.out.println("这是一个外部类");
}
public static class Inner{
public void in(){
System.out.println("这是一个内部类");
}
//内部类可以获得外部类的私有属性以及方法
public void getoutId(){
//静态内部类此时无法获得id原因可以参考内存的解释 之后外部类的属性变量也是静态的才可以加载id
System.out.println(id);
}
}
}
3.匿名内部类
定义顾名思义就是没有名字的类。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
//没有名字初始化的类不用将实例保存在变量中
new B().eat();
UseService useService = new UseService() {
@Override
public void Hello() {
}
};
}
}
class B{
public void eat(){
System.out.println("干饭!");
}
}
interface UseService{
void Hello();
}4.局部内部类
定义局部内部类就是定义在代码块内的一个内部类。
局部内部类的作用范围仅仅就在它所在的代码块里。局部内部类不能被public protectedprivate以及static修饰但是可以被final修饰。
/**
* @Author代码贩子、 --南京邮电大学
*/
public class A {
public void method(){
class Inner{
public void in(){
}
}
}
}
11.异常
定义在程序运行过程中出现的错误称为异常。异常就是程序运行过程中出现了不正常现象导致程序的中断。在Java中把各种异常现象进行了抽象形成了异常类。
分类检查时异常；运行时异常；错误。
检查时异常检查时异常最具有代表性的就是用户错误或者是问题引起的异常这种异常是我们程序员无法进行预测的。例如我们要打开一个文件时文件不见了这些异常都是在编译时不能被简单的忽略的。
运行时异常运行时异常是可能被程序员避免的异常与检查时异常相反运行时异常可以在编译时被忽略。
错误错误不是异常而是不被程序员控制的问题错误在代码中通常被忽略。例如当栈溢出时错误就产生了并且在程序编译的时候也无法被找到。
部分异常体系结构如下图所示
1.抛出以及捕获异常
关键字try、catch、final、throw、throws。
try抛出异常（尝试着去处理什么东西。
catch捕获异常。
final无论有什么异常发生finally都会被执行（可以运行清理类型等收尾善后性质的语句。
throw当程序发生异常而无法处理的时候会抛出对应的异常对象。
throwsthrows用来在类中捕获异常信息标明方法可能抛出的异常。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
int a = 1;
int b = 0;
try {//监控区域
System.out.println(a/b);
}catch (ArithmeticException e){
System.out.println("程序出现异常变量b不能为0");
}finally {//finally一般用来处理善后工作
System.out.println("finally");
}
}
}
注意
1.程序的最后可以不要finally 。IO流以及资源需要关闭通常放在finally里面。
2.捕获异常可以catch多个但是要把作用域最小的放在上面。
3.快捷方式选中要捕获异常的代码 ctrl+t选择异常类即可。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
int a = 1;
int b = 0;
try {//监控区域
Demo01 demo01 = new Demo01();
//System.out.println(a/b);
demo01.a();
}catch (Exception e){//catch里面存放的是想要捕获的异常类型
System.out.println("程序出现异常变量b不能为0");
}catch (Throwable t){
System.out.println("异常");
}finally {//finally一般用来处理善后工作
System.out.println("finally");
}
}
public void a(){
b();
}
public void b(){
a();
}
}
我们也可以用throw来主动抛出异常。
public class Demo01 {
/**
* @Author代码贩子、 --南京邮电大学
*/
public static void main(String[] args) {
int a = 1;
int b = 0;
try {
new Demo01().text(1,0);
}catch (ArithmeticException e){
e.printStackTrace();
}
}
//假如这个方法中处理不了这个异常方法上抛出异常,在调用闪光也要进行捕获
public void text(int a, int b) throws ArithmeticException{
if (b == 0) {//主动抛出异常 throw 一般用在方法中
throw new ArithmeticException();
}
System.out.println(a/b);
}
}2.自定义异常
定义使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外用户还可以自定义异常用户自定义异常类只需要继承Exception类即可。
在程序中使用自定义异常类大体可以分为以下步骤。
1.创建自定义常类。
2.在方法中通过throw关键字抛出异常。
3.如果在当前抛出异常的方法中处理异常可以使用try——catch语句来捕获异常并处理否则在方法的声明处通过throws关键字指明要抛出给方法调用的异常继续下一步操作。
4.在出现异常方法的调用者中捕获并处理异常。
public class Text {
static void Test(int a) throws Demo01 {
if(a>10){
throw new Demo01(a);//抛出
}else{
System.out.println("传递的参数为"+a);
}
}
public static void main(String[] args) {
try {
Test(1);
}catch (Demo01 e){
System.out.println("Demo01"+e);
}
}
}
//继承Except异常类
public class Demo01 extends Exception{
/**
* @Author代码贩子、 --南京邮电大学
*/
//传递数字
private int detial;
public Demo01(int a) {
this.detial = a;
}
//异常的打印信息
@Override
public String toString() {
return "Demo01{" +
"detial=" + detial +
'}';
}
}
总结
1.处理运行时异常时采用逻辑法合理规避同时辅助try——catch处理。
2.在多重catch快后面可以加一个catch（Exception来处理可能会被遗漏的异常。
3.对于不确定的代码也可以加上try——catch处理潜在的异常。
4.尽量去处理异常切忌只是简单的调用printStackTrace（去打印输出。
5.具体如何处理异常要根据不同的业务需求和异常类的类型去决定。
6.尽量添加finally语句块去释放占用的资源。