面向对象编程
Hello，World！
-
随便新建一个文件夹，存放代码
-
新建一个Java文件
- 文件后缀名为.java
- Hello.java
-
编写代码
public class Hello{ public static void main(String[] args){ System.out.print("Hello,World"); } } -
编译javac java文件，会生成一个class文件
-
运行class文件，Java class文件
可能遇到的问题
- 每个单词的大小不能出现问题，Java的大小写是敏感的
- 尽量使用英文
- 文件名和类名必须保证一致，并且首字母大写
- 符号使用中文
Java基础语法
注释
// 单行注释
/**/多行注释
标识符
关键字
起名不可与关键字重复
-
所有的标识符都应该以字母（A-Z或者a-z），美元$,或者下划线（_）开始
-
首字母之后可以说是任意字符组合
-
不能使用关键字作为变量名或方法名
-
标识符是大小写敏感的
public class HelloWorld { public static void main(String[] args) { System.out.println("Hello,World!"); String student ="tyz"; String 认真学习的人 ="tyz"; System.out.println(认真学习的人); } //单行注释，输出一个HelloWorld! //多行注释 /* 注释 */ /* 多 行 注 释 */ //JavaDoc:文档注释 /** */ /** * @Description HelloWorld * @Author tyz */ }
数据类型
-
强类型语言
要求变量的使用严格符合规定，所有的变量都必须先定义后才能使用。
-
弱类型语言
Java的数据类型分为两大类
基本类型
-
数值类型
- 整数类型：byte，short，int，long
- 浮点类型：float，double
- 字符类型：char
-
boolean类型：只要true和false两个
//八大基本数据类型 //整数 int num1=10; //最常用 byte num2=20; short num3=30; long num4=40L; //long类型要在数字后面加个L用于区分 //小数：浮点型 float num5=50.1F;//float类型要在数字后面加个F用于区分 double num6=3.1415926; //字符 char name ='田'; //字符串,String不是关键字，是类 //String namea="田耀宗"; //布尔值：是非 boolean flag=true; //boolean flag=false;
引用类型（除基本类型以外）
-
-
类
-
接口
-
数组
数据类型扩展
//整数拓展 进制， 二进制 十进制 八进制0 十六进制0x(0~9 A~F)
//----------------------------------------
//浮点数拓展？ 银行业务怎么展示？钱
//BigDecimal 数学工具类
//-------------------------------------------
//float 有限 离散 舍入误差 大约 接近但不等于
//double
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
//最好完全使用浮点数进行比较
float f=0.1f;//0.1
double d=1.0/10;//0.1
System.out.println(f==d);//输出为false
System.out.println(f);
System.out.println(d);
float d1=23333333333333333F;
float d2=d1+1;
System.out.println(d1==d2);//输出为true
//----------------------------------------------
//字符拓展
char c1='a';
char c2='田';
System.out.println( c1);
System.out.println((int)c1);//强制换行
System.out.println(c2);
System.out.println((int)c2);//强制换行
//所有的字符本质还是数字
//编码 Unicode 表：97=a 3000=田 占2字节
//U000 UFFF
char c3='\u0061';
System.out.println(c3);//a
//------------------------
//转义字符
//\t 制表符
//\n 换行
//---------------
//对象 从内存分析
//----------------------------------
//布尔值扩展
boolean flag=true;
if (flag==true){//新手
//if(flag){}老手，两者意思相同
类型转换
int i = 128;
byte b=(byte) i;//内存溢出
//强制转换 （类名）变量名 高到低
//自动转换 低到高
double d=i;
System.out.println(i);
System.out.println(b);
System.out.println(d);
/*
注意点
1.不能对布尔值进行转换
2.不能把对象类型转换为不相干的类型
3.在把高容量转换为低容量的时候，强制转换
4，在转换的时候可能存在内存溢出或者精度问题
*/
System.out.println((int)23.7);//输出为23
//===================================
char c='a';
int f=c+1;
System.out.println(f);//输出为98（a=97）
System.out.println((char) f);//输出为b
类型转换的常见问题
public static void main(String[] args) {
//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money=10_0000_0000;
int years=20;
int total=money*years;//输出为-1474836480，计算的时候溢出了
long total2=money*years;//输出还是为-14..，默认是int，转换之前已经存在问题
long total3=money*((long)years);//先把一个数转换为long类型
System.out.println(total);
System.out.println(total2);
System.out.println(total3);//输出为20亿
}
变量
数据类型 变量名 = 值；
- 每个变量都必须声明其类型
- 要素包括变量名，变量类型和作用域
注意
-
每个变量都有类型，类型可以是基本类型，可以是引用类型。
-
变量名必须是合法的标识符。
-
变量声明必须是一条完整的语句，因此每一个声明都必须以分号结束。
变量的作用域
- 类变量
- 实例变量
- 局部变量
public class Demo08变量作用域 {
//类变量 static
static double salary=2500;
//属性：变量
//实例变量：从属于对象（这个类）；如果不自行初始化，会变成这个类型的默认值
//布尔值：默认是false
//除了基本变量类型，其余的默认值都是null。
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量；必须声明和初始化值,只在这一种方法中有效
int i=10;
System.out.println(i);
//变量类型 变量名字=new Demo08（）；
Demo08变量作用域 demo08变量作用域=new Demo08变量作用域();
System.out.println(demo08变量作用域.age);
System.out.println(demo08变量作用域.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
变量的命名规范
- 所有变量，方法，类名：见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary除了第一个单词意外，后面的单词首字母大写（lastName）
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线MAX_VALUE
- 类名：首字母大写和驼峰原则：Man，GoodMan
- 方法名：首字母小写和驼峰原则：run（），runRun（）
常量
常量：初始化后不能在改变的值！不会变动的值。
final 常量名=值;
常量名一般使用大写字符
public class Demo09常量 {
//修饰符，不存在先后顺序
static final double PI=3.14;
public static void main(String[] args) {
}
}
运算符
算术运算符：+-*%（余），++，--
package operator;
public class Demo01算数运算符 {
public static void main(String[] args) {
//二元运算符
//ctrl+D复制当前行到下一行
int a=10;
int b=20;
int c=30;
int d=40;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b);
long e=123123123123L;
int f=123;
short g=10;
byte h=8;
double i=3;
System.out.println("===============================");
System.out.println(e+f+g+h);//输出为Long
System.out.println(f+g+h);//输出为int
System.out.println(g+h);//输出为int
System.out.println(i+g);
}
}
赋值：=
关系：>,<,<=,>=,==(等于)，！=（不等于），instanceof
package operator;
public class Deom02关系运算符 {
public static void main(String[] args) {
//关系运算符返回结果
int a=10;
int b=20;
int c=21;
System.out.println(c%a);
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
}
}
逻辑：&&与 ||或， ！非
package operator;
public class Demo04逻辑运算符 {
public static void main(String[] args) {
boolean a=true;
boolean b=false;
System.out.println("a&&b:"+(a&&b));//false
System.out.println("a||b:"+(a||b));//true
System.out.println("!(a&&b):"+!(a&&b));//true
//短路运算
System.out.println("a&&b:"+(b&&a));//a不进行运算
int c=5;
boolean d=(c<4)&&(c++<4);//由于c<4是false,c++不进行运算
System.out.println(d);//输出为false
System.out.println(c);//输出为5，没有自增
}
}
位运算符
package operator;
public class Demo05位运算 {
public static void main(String[] args) {
/*
A =0011 1100
B =0000 1101
------------------------------------------------
A&B=0000 1100 两者相同输出1，不同0
A/B=0011 1101 两者有1则输出1
A^B=0011 0001 亦或：相同取0，不同取1
~B =1111 0010 取反：与原来相反
2*8=16 2*2*2*2
效率极高！！！
<<左移 相当于*2
>>右移 相当于/2
*/
System.out.println(2<<3);
}
}
条件
package operator;
public class Demo07三元运算符 {
public static void main(String[] args) {
//?: x? y : z
//如果x==true，则结果为y，否则结果为z
int score=80;
String type=score<60?"不及格":"及格";
System.out.println(type);//及格
}
}
扩展赋值
package operator;
public class Demo06扩展赋值运算符 {
public static void main(String[] args) {
int a=10;
int b=20;
a+=b;//a=a+b
a-=b;//a=a-b
//字符串连接符 + 如果出现String出现，那么后面其他操作数都转化为string类型进行链接
System.out.println(a+b);//30
System.out.println(""+a+b);//1020
System.out.println(a+b+"");//30
}
}
++a先自增
a++后自增
package operator;
public class Deom03自增自减 {
public static void main(String[] args) {
//++自加 --自减 一元运算符
int a=3;
int b=a++;//执行这段代码后，先给b赋值，a再自增
//a=a+1
System.out.println(a);
int c=++a;//执行这段代码前，先给a自增，再给c赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算
double pow = Math.pow(2, 3);
System.out.println(pow);
}
}
包机制
本质就是一个文件加
把语句的语法格式：
package pkg1[.pkg2[.pkg3...]];
- 一般利用公司域名倒置作为包名；
- 为了能够使用某一个包的成员，我们需要导入该包，使用import语句
import package1.[.package2...].(classname|*);
import com.kuang.bacs.*;导入这个包下所有的类！
JavaDOC
javadoc命令是用来生成自己API文档的
参数信息
- @author 作者名
- @version版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return返回值情况
- @throws异常抛出情况
Java流程控制
Scanner
scanner就是用户与电脑（程序）互动
我们可以通过Scanner类来获取用户的输入
基本语法
Scanner s=new Scanner(System.in);
变量类型 变量名=scanner.Next变量类型；
scanner.close();
凡是属于IO流（输入输出流）的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
通过Scanner类的next（）与nextLine（）方法获取输入的字符串
使用hasNext（）与hasNextLine（）判断是否还有输入的数据
next（）
-
一定要读取到有效字符后才可以结束输出
-
遇到空格后面的字符将去掉
-
package scanner; import java.util.Scanner; public class Demo01 { public static void main(String[] args) { //创建一个扫描器对象，用于接收键盘数据 Scanner scanner = new Scanner(System.in); System.out.println("使用next方式接收："); //判断用户有没有输入字符串 if (scanner.hasNext()==true){ //使用next方式接收用户的输入 String str=scanner.next();//程序会等待用户输入完毕 System.out.println("输出的内容为："+str); } //凡是属于IO流（输入输出流）的类如果不关闭会一直占用资源，要养成好习惯用完就关掉 scanner.close(); } }
nextLine（）
-
可以有空白
-
package scanner; import java.util.Scanner; public class Demo02 { public static void main(String[] args) { //从键盘接收数据 Scanner scanner = new Scanner(System.in); System.out.println("使用nextLine方式接收："); //判断是否还有输入 if (scanner.hasNextLine()==true){ String str = scanner.nextLine();//等待用户输入 System.out.println("输出的内容为："+str); } scanner.close(); } }也可以不用if语句
package scanner; import java.util.Scanner; public class Demo03 { public static void main(String[] args) { //从键盘接收数据 Scanner scanner = new Scanner(System.in); System.out.println("请输入数据："); String str = scanner.nextLine();//等待用户输入 System.out.println("输出的内容为：" + str); scanner.close(); } }Scanner也可以有其他用法，可以用基本数据类型
package scanner;
import java.util.Scanner;
public class Demo04 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
//从键盘接收数据
int i=0;
float f=0.0f;
System.out.println("请输入整数数据：");
//if语句
if (scanner.hasNextInt()==true){
i = scanner.nextInt();
System.out.println("整数数据："+i);
}
else{
System.out.println("输入的不是整数数据！");
}
//=============================================================
System.out.println("请输入小数数据：");
//if语句
if (scanner.hasNextFloat()==true){
f = scanner.nextFloat();
System.out.println("小数数据："+f);
}
else{
System.out.println("输入的不是小数数据！");
}
scanner.close();
}
}
package scanner;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
//我们要输入多个数字，并且求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果；
Scanner scanner = new Scanner(System.in);
//和
double sum=0;
//计算输入了多少个数字
int m=0;
System.out.println("请输入数据");
//通过循环判断是否还有输入，并且在里面对每一次进行求和和统计
while (scanner.hasNextDouble()==true){
double x = scanner.nextDouble();
//m=m+1
m=++m;
sum=sum+x;
System.out.println("当前输入了第"+m+"个数据,当前结果sum="+sum);
}
System.out.println(m+"个数和为："+sum);
System.out.println(m+"个数的平均值是：："+(sum/m));
scanner.close();
}
}
顺序结构
java的基本结构
选择结构
if单选择结构
package struct;
import java.util.Scanner;
public class Demo01if单选 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个内容：");
String s = scanner.nextLine();
//equals判断字符串是否相等
if (s.equals("Hello")){
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
if双选择结构
package struct;
import java.util.Scanner;
public class Demo02if双选择 {
public static void main(String[] args) {
//考试分数大于60分就是及格，小于60分就是不及格。
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
int score = scanner.nextInt();
if (score>=60){
System.out.println("及格");
}
else {
System.out.println("不及格");
}
scanner.close();
}
}
if多选择结构
if(){
}else of(){
}else of(){
}else of(){
.....
}else
}
package struct;
import java.util.Scanner;
public class Demo03多选择结构 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩:");
int score = scanner.nextInt();
if (score==100){
System.out.println("恭喜满分！");
}else if (score<100&&score>=90){
System.out.println("A级");
}else if (score<90&&score>=80){
System.out.println("B级");
}else if (score<80&&score>=70){
System.out.println("C级");
}else if (score<70&&score>=60) {
System.out.println("D级");
}else if (score<60&&score>=0) {
System.out.println("不及格");
}else {
System.out.println("成绩不合法");
}
scanner.close();
}
}
switch多选择结构
反编译，把class文件反编译为java文件
点击项目结构，打开项目编译输出的路径，找到class文件，复制到idea文件夹中，从idea中打开文件夹
package struct;
public class Demo02switch {
public static void main(String[] args) {
String name="田";
//字符的本质还是数字
//反编译 java编译---class（字节码文件）---反编译
switch (name){
case "tyz":
System.out.println("tyz");
break;
case"田":
System.out.println("田");
break;
default:
System.out.println("弄啥嘞？");
}
}
}
循环结构
while循环
避免死循环
计算1加到100
package struct;
public class Demo02while循环 {
public static void main(String[] args) {
//计算1+2+3.。。。+100=？
int i=0;
int sum=0;
while (i<=100){
sum=sum+i;
i++;
}
System.out.println(sum);
}
}
do...while循环
至少会执行一次
package struct;
public class Demo02dowhile循环 {
public static void main(String[] args) {
int a=0;
while (a<0){
System.out.println(a);//不输出
a++;
}
System.out.println("==================================");
do {
System.out.println(a);//输出0
a++;
}while (a<0);
}
}
for循环（最有效最灵活）
for（初始化值；布尔值；更新值）{
//代码
}
快捷键：条件判断.for
计算0~100之间奇数和偶数的和
package struct;
public class for循环Demo02 {
public static void main(String[] args) {
//0~100之间奇数和偶数和
int oddSum=0;//奇数和
int evenSum=0;//偶数和
for (int i = 0; i <=100; i++) {
if (i%2!=0){
oddSum+=i;
}else {
evenSum+=i;
}
}
System.out.println("奇数的和："+oddSum);
System.out.println("偶数的和："+evenSum);
}
}
for循环1~1000之间能被5整除的数，并且每行输出3个
package struct;
public class for循环Demo03 {
public static void main(String[] args) {
//1~1000能被5整除的数 ，并且每行输出三个
for (int i = 0; i <= 1000; i++) {
if (i%5==0){
System.out.print(i+"\t");//转义字符
}
if(i%(5*3)==0){//换行
System.out.println();
//System.out.println("\n");
}
}
//println输出完换行
//print输出完不换行
}
}
for循环的九九乘法表
package struct;
public class for循环打印99乘法表Demo04 {
public static void main(String[] args) {
//去掉重复项，用i<=j判断语句
for (int j= 1; j <= 9; j++) {
for (int i = 1; i <=j; i++) {
System.out.print(i+"*"+j+"="+(i*j)+"\t");
}
System.out.println();
}
}
}
增强for循环
package struct;
public class for循环增强for循环Demo05 {
public static void main(String[] args) {
int [] numbers={10,20,30,40,50};//定义了一个数组
for (int i=0;i<5;i++){
System.out.println(numbers[i ]);
}
System.out.println("===================");
//输出遍历数组的元素
for (int x:numbers){
System.out.println(x);
}
}
}
break,continue
break在任何循环语句的主体部分，都可以用break控制循环结束
break用于强行退出循环，不执行循环中剩余的语句（break语句也在switch语句中使用）
continue语句用与循环语句中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定
break
package struct;
public class breakDemo01 {
public static void main(String[] args) {
int i=0;
while (i<100){
i++;
System.out.println(i);
if (i==30){
break;
}//输出1-30
}
}
}
continue
package struct;
public class continueDemo01 {
public static void main(String[] args) {
int i=0;
while (i<100){
i++;
if (i%10==0){
System.out.println();
continue;
}
System.out.println(i);//到10的倍数输出空格
}
}
}
练习打印三角形
package struct;
public class 练习打印三角形Demo01 {
public static void main(String[] args) {
//打印三角形 打印5行三角形
for (int i = 1; i <= 5; i++) {
for (int j=5;j>=i;j--){
System.out.print(" ");
}
for (int k=1;k<=i;k++){
System.out.print("*");
}
for (int l=1;l<i;l++){
System.out.print("*");
}
for (int m=5;m>=i;m--) {
System.out.print(" ");
}
System.out.println();
}
}
}
Java的方法
保持原子性：一个方法只完成一个功能，有利于后期的扩展
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或者对象中
- 方法在程序中被创建，在其他地方被引用
package method;
public class Demo01 {
//main 方法
public static void main(String[] args) {
//实际参数，实际调用传递给他的参数
int sum =add(1,2);
System.out.println(sum);
test();
}
//加法 方法
//形式参数，用来定义作用的
public static int add(int a,int b){
return a+b;
}
//调用for循环
public static void test(){
//1~1000能被5整除的数 ，并且每行输出三个
for (int i = 0; i <= 1000; i++) {
if (i%5==0){
System.out.print(i+"\t");//转义字符
}
if(i%(5*3)==0){//换行
System.out.println();
//System.out.println("\n");
}
}
}
}
方法的定义
一段用来完成特定功能的代码片段
修饰符 返回值类型 方法名（参数类型 参数名）{
。。。
方法体
。。。
return 返回值；
}
-
修饰符：是可选的
-
返回值类型：方法可能返回值，输出一句话返回值为void（为空）
-
方法名：方法的实际名字（首字母小写，驼峰）
-
参数类型:像是一个占位符，可选，也可以不包含任何参数
- 形式参数：在方法被调用时用于接收外界输入的数据
- 实参：调用方法实际传给方法的数据
-
方法体：方法里的具体语句，定义该方法的功能
package method;
public class Demo02 {
public static void main(String[] args) {
//int max = max(10, 20);
System.out.println(max(10,20));
}
//比大小的方法
public static int max(int i,int j){
int result=0;
if (i>j){
result=i;
}else if (i==j){
System.out.println("一样大");
return 0;//return有终止方法的意思
}else {
result=j;
}
return result;
}
}
方法的调用
如果返回值是void，那么返回值一定是一条语句
当方法返回一个值的时候，方法调用通常被当作一个值
方法的重载
重载就是在一个类中，有相同的函数名称，但形参不同的函数
规则：
- 方法名称必须相同
- 参数列表必须不同（个数，类型，参数排列顺序）
命令行传参
运行程序的时候再传给程序数据，需要靠传递命令行参数给main（）函数实现。
可变参数
- 在方法声明中，在指定参数类型后加一个”...“
- 一个方法只能指定一个可变参数，它必须是方法的最后一个参数，任何普通参数必须在他之前声明
递归
边界条件
前阶段
返回阶段
package method;
public class Demo03 {
//阶乘
public static void main(String[] args) {
System.out.println(f(5));
}
public static int f(int n){
if (n==1){
return 1;//边界条件
}else {//前阶段
return n*f(n-1);//返回阶段
}
}
}
自己调用自己
递归结构包括两个部分
- 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法
计算器的编程（scanner，switch）
package method;
import java.util.Scanner;
public class 计算器Demo4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个数字");
double num1 = scanner.nextInt();
System.out.println("请输入运算符");
String operator1 = scanner.next();
System.out.println("请输入第二个数字");
double num2 = scanner.nextInt();
System.out.println("请输入运算符");
String operator2 = scanner.next();
System.out.println("请输入第三个数字");
double num3 = scanner.nextInt();
double result1=0;
double result2=0;
switch (operator1){
case "+":
result1=num1+num2;
break;
case "-":
result1=num1-num2;
break;
case "*":
result1=num1*num2;
break;
case "/":
result1=num1/num2;
break;
default:
System.out.println("您的输入不合法！");
return ;
}
//==============================================
switch (operator2){
case "+":
result2=result1+num3;
break;
case "-":
result2=result1-num3;
break;
case "*":
result2=result1*num3;
break;
case "/":
result2=result1/num3;
break;
default:
System.out.println("您的输入不合法！");
return ;
}
System.out.println("结果是："+num1+operator1+num2+operator2+num3+"="+result2);
scanner.close();
}
}
Java数组
定义
- 相同类型数据的有序集合
- 相同类型的若干个数据，按照一定的先后次序排列组合而成
- 每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问他们
声明创建
数据类型[] 变量名=new 数据类型[数组大小]；
数组长度：arrays.length
package struct;
public class for循环增强for循环Demo05 {
public static void main(String[] args) {
int [] numbers={10,20,30,40,50};//定义了一个数组
for (int i=0;i<5;i++){
System.out.println(numbers[i ]);
}
System.out.println("===================");
//输出遍历数组的元素
for (int x:numbers){
System.out.println(x);
}
}
}
三种初始化
-
静态初始化
-
动态初始化
-
数组的默认初始化
数组是引用类型，它的元素相当于类的实例变量。因此数组一经分配空间（int[] a=new int[10];）,其中每个元素也被按照实例变量被隐式初始化
package array;
public class arrayDemo02 {
public static void main(String[] args) {
//静态初始化:创建加赋值
int[] a={1,2,3,4,5,6,7,8};
System.out.println(a[0]);//输出1
//动态初始化:包含默认初始化
int[] b=new int[10];
b[0]=10;
System.out.println(b[0]);
数组的四个特点
- 其长度是确定的，数组一旦被创建，它的大小就是不可改变的
- 必须是相同类型
- 可以是任意数据类型，包括基本类型和引用类型
- 属于引用类型，数组可以看成是对象，数组中的每个元素都相当于该对象的成员变量。数组本身就是对象，Java中的对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
数组边界：合法区间[0,length-1]
越界：ArrayIndexOutOfBoundsException:数组下标越界
数组的使用
- 普通的for循环
package array;
public class arrayDemo03for循环 {
public static void main(String[] args) {
int[] array={1,2,3,4,5};
//打印全部的数组元素
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
//计算所有元素的和
int sum=0;
//获取数组长度：arrays.Length
for (int i = 0; i <array.length ; i++) {
sum+=array[i];
}
System.out.println("和为："+sum);
//找最大数
int max=array[0];
for (int i = 1; i < array.length; i++) {
if (array[i] >=max){
max=array[i];
}
}
System.out.println("最大值为："+max);
}
}
-
for-Each循环
-
数组作方法入参
-
数组作为返回值
package array;
public class arrayDemo04forEach循环 {
public static void main(String[] args) {
int[] arrays = {1, 2, 3, 4, 5};
//没有下标 array为array[]数组中的元素
for (int array : arrays) {
System.out.println(array);
}
System.out.print("数组元素为：");
printArray(arrays);//打印数组元素
System.out.println('\n');
System.out.print("数组元素反转为：");
int[] reverse = reverse(arrays);//打印反转后数组元素
printArray(reverse);
}
//--------------------------------------------------------------
//打印数组元素
//创建一个方法，输出数组元素
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+"");
}
}
//--------------------------------------------------------------
//反转数组
//创建一个方法，反转数组元素
public static int[] reverse(int[] arrays) {
int[] result=new int[arrays.length];
for (int i = 0, j=result.length-1;i<result.length; i++,j--) {
//result[]=arrays[i];
result[j]=arrays[i];
}
return result;
}
}
多维数组
package array;
public class arrayDemo05多维数组 {
public static void main(String[] args) {
//定义了一个四行两列的数组
/*
1，2 array[0]
2，3 array[1]
3，4 array[2]
4，5 array[3]
*/
int[][] array={{1,2},{2,3},{3,4},{4,5}};
printArray(array[0]);
System.out.println('\n');
System.out.println(array[0][0]);
System.out.println(array[0][1]);
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.println(array[i][j]);//输出数组的元素
}
}
}
//创建一个方法，输出数组元素
public static void printArray(int[] arrays) {
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+"");
}
}
}
Arrays类
给数组赋值：通过fill方法
给数组排序：通过sort，按升序
比较数组：equals比较数组中元素值是否相等
查找数组元素：通过binarySearch能对排序号的数组进行二分查找法操作
package array;
import java.util.Arrays;
public class arrayDemo06类的使用 {
public static void main(String[] args) {
int[]a={1,2,3,4,1231,434,5433,64363};
//System.out.println(a);输出为[I@1b6d3586
//打印数组元素Arrays.toString
System.out.println(Arrays.toString(a));
//数组进行排序，升序Arrays.sort
Arrays.sort(a);
System.out.println(Arrays.toString(a));
Arrays.fill(a,2,4,0);//数组填充，2~4填充为0
System.out.println(Arrays.#ing(a));
}
}
面向对象编程
方法
break和return的区别
break：跳出switch，结束循环
return：结束方法，返回一个值
package com.oop;
import java.io.IOException;
//Demo01就是一个类
public class Demo01 {
//main方法
public static void main(String[] args) {
}
/*
修饰符 返回值类型 方法名（。。。）{
方法体
return 返回值；
}
*/
//return结束方法，返回一个结果！
public String sayHello(){
return "Hello,world";
}
public void hello(){
return;
}
public int max(int a,int b){
return a>b?a:b;//三元运算符
}
public void readFile(String file)throws IOException{//抛出异常
}
}
调用
package com.oop;
public class Demo02 {
public static void main(String[] args) {
//实例化这个类 new
//对象类型 对象名=对象值
Student student = new Student();
student.say();
}
//static和类一起加载的
public static void a(){
}
//类实例化之后才存在
public void b(){}
}
实参形参
package com.oop;
public class Demo03 {
public static void main(String[] args) {
//实际参数和形式参数类型要对应
int add = add(1, 2);
System.out.println(add);
}
public static int add(int a,int b){
return a+b;
}
}
值传递
package com.oop;
//值传递
public class Demo04 {
public static void main(String[] args) {
int a=1;
System.out.println(a);
charge(a);
System.out.println(a);//1
}
//返回值为空
public static void charge(int a){
a=10;
}
}
引用传递
package com.oop;
//引用传递：传递一个对象，本质还是值传递
public class Demo05 {
public static void main(String[] args) {
Perosn perosn = new Perosn();
System.out.println(perosn.name);//输出为null
Demo05.charge(perosn);
System.out.println(perosn.name);
}
public static void charge(Perosn perosn ){
//perosn是一个对象，指向的是————>Perosn perosn = new Perosn();这是一个具体的人，可以改变属性
perosn.name="田耀宗";
}
}
//定义了一个Perosn类，有一个属性：name
class Perosn{
String name;//null
}
创建和初始化对象
使用new关键字
面向对象编程的本质是：以类的方式组织代码，以对象的组织（封装）数据
package com.oop.Demo02;
//学生类
public class Student {
//属性：字段
String name;//null
int age;//0
//方法
public void study(){
System.out.println(this.name+"学生在学习");
}
}
package com.oop.Demo02;
//一个项目一应该只存在一个main方法
public class Application应用 {
public static void main(String[] args) {
//类是抽象的，需要实例化
//类实例化后会返回一个自己的对象
//student对象就是一个Student类的具体实例
Student xiaoming = new Student();
Student xiaohong = new Student();
System.out.println(xiaoming.name);
xiaoming.name="小明";
xiaoming.age=3;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
}
}
构造器
alt+insert
package com.oop.Demo02;
//java->class
public class Person {
//一个类即使什么都不写，它也会存在一个方法
//显示的定义构造器
String name;
int age;
//实例化初始值
//1.使用new关键字，本质还是调用构造器
//2.构造器用来初始化值
public Person() {
this.name = "田耀宗";
}
//重载
//有参构造：一旦定义了有参构造，无参构造就必须显示定义
public Person(String name) {
this.name = name;//this.name指的是这个类的name，后面的形参传递下来的name
}
//快捷键alt+insert
/*
public Person() {
}
public Person(String name) {
this.name = name;
}
}
*/
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
/*
public static void main(String[] args) {
//new 实例化了一个对象
Person person = new Person();
System.out.println(person.name);//null
Person person = new Person("田耀宗");
System.out.println(person.name);//田耀宗
}
*/
//构造器：1.方法名和类名相同
// 2.没有返回值
//作用：1.new本质在调用构造器
// 2.初始化对象的值
//注意：1定义有参构造之后，如果想使用无参构造，必须显示的定义一个无参构造
//alt+insert
类和对象
1.类是一个模板：抽象，对象是一个具体的实例：
2.方法：定义，调用
3.对象的引用：
引用类型：基本类型
对象是通过引用来操作的：栈-->堆
4.属性:字段（Field 成员变量）
默认初始化
修饰符 属性类型 属性名=属性值；
5.对象的创建和使用
必须使用new关键字创造对象，创造器Preson tyz= new Preson（）；
对象的属性 tyz.name
对象的方法tyz.sleep（）
6类：
静态的属性 属性
动态的行为 方法
封装
属性私有，get/set
ALT+insert
package com.oop.Demo04;
//类 private:私有
public class Student {
//属性私有
private String name;//名字
private int id;//学号
private char sex;//性别
private int age;
//提供一些可以操作这个属性的方法
//提供一些public的get/set方法
//get获得这个数据
public String getName(){
return this.name;
}
//set给这个数据设置值
public void setName(String name){
this.name=name;
}
//alt+insert
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>120||age<0){//不合法
this.age=3;
}else {
this.age = age;
}
}
/* public static void main(String[] args) {
Student s1 = new Student();
s1.setName("田耀宗");
//
System.out.println(s1.getName());
s1.setAge(999);//不合法
System.out.println(s1.getAge());
}
*/
}
/*
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.提高了系统的可维护性
*/
}
继承
类和类的一种关系
子类（派生类） 父类（基类）
package com.oop.Demo05;
//在Java中，所有的类，都默认直接或者间接继承object类
//Person 人 父类
public class Person {
//public
//protected
//default
//private
private int money=10_0000_0000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
package com.oop.Demo05;
//学生 is 人 :派生类 ；子类
public class Student extends Person {
//ctrl + h
}
super
super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造器
Vs this：
代表对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提：
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法：
this（）：本类的构造
super（）：父类的构造
package com.oop.Demo05;
import javax.swing.plaf.synth.SynthOptionPaneUI;
//在Java中，所有的类，都默认直接或者间接继承object类
//Person 人 父类
public class Person {
public Person(){
System.out.println("Person无参执行了");
}
protected String name="tyz";
public void print(){
System.out.println("Person");
}
}
package com.oop.Demo05;
//学生 is 人 :派生类 ；子类
public class Student extends Person {
private String name="田耀宗";
public Student(){
//隐藏代码：调用了父类的无参构造
super();//调用父类的构造器，必须放在子类构造器的第一行
System.out.println("Student无参执行了");
}
public void print() {
System.out.println("Student");
}
public void test1(){
print();
this.print();
super.print();
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
package com.oop;
import com.oop.Demo03.Pet;
import com.oop.Demo05.Student;
//一个项目一应该只存在一个main方法
public class Application应用 {
public static void main(String[] args) {
Student student = new Student();
//student.test("耀宗");
//student.test1();
}
}
重写
alt+insert：override
不能被重写
1.static 方法，静态方法属于类，不属于实例
2.final 常量，无法改变
3.private 方法
重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大： public>Protected>Default>private
4.抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException(小)-->Exception（大）
重写：子类的方法和父类必须要一致，方法体不同！
为什么需要重写
父类的功能子类不一定需要或者比一定满足
package com.oop.Demo05;
public class A extends B{
//@Override 重写
@Override//注释，有功能的注释
public void test(){
System.out.println("A=>test()");
}
}
package com.oop.Demo05;
//重写都是方法的重写，和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
public class Application应用 {
//静态方法和非静态方法区别很大
//静态方法：方法的调用只和左边，定义的数据类型有关
//非静态方法：重写
public static void main(String[] args) {
A a = new A();
a.test();//A
//父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.test();//B
}
}
多态
动态编译：类型：可扩展性
同一方法可以根据发送对象的不同而采用多种不同的行为方法
一个对象的实际类型是确定的，但是指向对象的引用类型有很多：父类，有关系的类
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系，不然会有类型转换异常！ClassCastException!
3.存在条件：继承关系，方法需要重写，父类的引用指向子类对象！ father f1=new Son（）
public class Person {
public void run(){
System.out.println("run");
}
}
/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系，不然会有类型转换异常！ClassCastException!
3.存在条件：继承关系，方法需要重写，父类的引用指向子类对象！ father f1=new Son（）
不能被重写
1.static 方法，静态方法属于类，不属于实例
2.final 常量，无法改变
3.private 方法
*/
public class Student extends Person {
@Override
public void run(){
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
public class Application应用 {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了,父类的引用指向了子类
//Student 能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行那些方法，只要看对象左边的类型，和右边关系不大
s2.run();//子类重写了父类的方法，执行了子类的方法
s1.run();
((Student)s2).eat();
}
instanceof和类型转换
1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型：强制转换
4.方便方法的调用，减少重复的代码！简洁
package com.oop.Demo06;
public class Student extends Person {
public void go(){
System.out.println("go");
}
}
/*
//Object>String
//Object>Person>Student
//Object>Person>Teacher
Object object = new Student();
//System.out.println(X instanceof Y);//能不能编译通过，取决于XY有没有父子关系，X指向的类型与Y有父子关系就是true
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
System.out.println("=========================");
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);//编译就报错
System.out.println("=========================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//编译就报错
//System.out.println(person instanceof String);//编译就报错
*/
package com.oop.Demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package com.oop.Demo06;
public class Teacher extends Person{
}
public class Application应用 {
public static void main(String[] args) {
//类型之间的转化：父 子
//高 低
Person obj = new Student();//低-->高
//obj将这个对象转换为Student类型，我们就可以使用Student类型的方法了
//Student student = (Student) obj;//高obj-->转换为Student类（低）
((Student) obj).go();
//子类转换为父类，可能丢失自己本来的一些方法
Student student = new Student();
student.go();
Person person=student;
}
}
/*
1.父类的引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型：强制转换
4.方便方法的调用，减少重复的代码！简洁
*/
static关键字详解
package com.oop.Demo07;
//Static:
public class Student {
private static int age;//静态变量
private double score;//非静态变量
public void run(){
}
public static void go(){
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age);//类变量
//不可直接调用类变量Student.score
System.out.println(s1.age);
System.out.println(s1.score);
new Student().run();
go();
}
}
代码块
package com.oop.Demo07;
public class Person {
//第2，可以赋初始值
{
System.out.println("匿名代码块");
}
static {
System.out.println("静态代码块");
}
//第1个输出,只执行一次
public Person(){
System.out.println("构造方法");
}
//第3
public static void main(String[] args) {
Person person1 = new Person();
System.out.println("=================");
Person person2 = new Person();
}
}
package com.oop.Demo07;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
//System.out.println(Math.random());随机数
System.out.println(random());
System.out.println(PI);
}
}
抽象类
package com.oop.Demo08;
//abstract抽象类 类：extends ：单继承（接口可以多继承）
public abstract class Action {
//约束，有人帮我们实现
//abstract,抽象方法，只有方法的名字，没有方法的实现
public abstract void doSomething();
}
/*
1.不能new这个抽象类，只能靠子类去实现它：约束！
2.抽象类中可以写普通的方法
3.抽象方法必须在抽象类中
抽象的抽象：约束
*/
package com.oop.Demo08;
//抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类也是abstract
public class A extends Action{
@Override
public void doSomething(){
}
}
接口
只有规范，自己无法写方法，约束和实现分离：面向接口编程
作用：
1.约束
2.定义一些方法，让不同的人实现
3.方法都是抽象的public abstract
4.常量都是public static final静态常量
5.接口不能被实例化，接口中没有构造方法
6.可以实现多个接口
7.必须要重写接口中的方法
package com.oop.Demo09;
//interface定义的关键字，接口都需要有实现类
public interface UserService {
//属性 public static final静态常量
int age=99;
//接口中的所有定义的方法其实都是抽象的 public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
package com.oop.Demo09;
//抽象类：extends
//类 可以实现接口 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(){
}
}
package com.oop.Demo09;
public interface TimeService {
void timer();
}
接口
定义interface
变量只能包含公开静态常量
无构造方法
通过implements关键字
可以有多个接口
抽象类
定义abstract
变量可以是任意修饰符的变量
可以包含构造方法
一个类只能继承一个抽象类
内部类
package com.oop.Demo10;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public static class Inner {
private final Outer outer;
public Inner(Outer outer) {
this.outer = outer;
}
public void in() {
System.out.println("这是内部类的方法");
}
//内部类访问外部类的私有变量,方法
public void getID() {
System.out.println(outer.id);
}
}
//局部内部类
public void method(){
class Inner{
public void in(){
}
}
}
}
//一个java类中可以有多个class类，但是只能有一个public class
class A{
}
package com.oop.Demo10;
public class Test {
public static void main(String[] args) {
//没有名字初始化类,不用将实例保存到变量中
new Apple().eat();
new UserService(){
@Override
public void hello(){
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
package com.oop;
import com.oop.Demo10.Outer;
//一个项目一应该只存在一个main方法
public class Application应用 {
public static void main(String[] args) {
//new
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inner = new Outer.Inner(outer);
inner.in();
inner.getID();
}
}
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 25岁的心里话
· 闲置电脑爆改个人服务器（超详细） #公网映射 #Vmware虚拟网络编辑器
· 零经验选手，Compose 一天开发一款小游戏！
· 通过 API 将Deepseek响应流式内容输出到前端
· 因为Apifox不支持离线，我果断选择了Apipost！