java基础
编写第一个java程序
/*第一行第三个单词必须要与所在的文件名称完全一样；
第三个单词也叫类
类：java当中所有源代码的基本组织单位
*/
public class HelloWorld {
//第二行是固定写法，为main函数，这一行代表程序的起点
public static void main(String[] args){
//第三行是屏幕输出语句
System.out.println("Hello,World!");
}
}
/*这是一段注释*/
对文件进行编译
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a4GkAUSC-1690428122584)(https://cdn.nlark.com/yuque/0/2023/png/22710349/1679923739118-c1a37102-d2a5-4c5b-ae2e-c0deec72da15.png#averageHue=%23141313&clientId=u5f87fbe3-41ea-4&from=paste&height=626&id=u47ad5c84&originHeight=626&originWidth=1113&originalType=binary&ratio=1&rotation=0&showTitle=false&size=57247&status=done&style=none&taskId=u7f922b8f-15ae-43e6-a1b0-cad14298ccf&title=&width=1113)]
生成class文件
关键字和标识符
关键字的特点
1、完全小写的字母。
2、在编译软件中有特殊颜色
标识符
- 命名规则
- 标识符可以包含英文字母26个、0-9数字、$、_
- 标识符不能以数字开头，也不能是关键字
- 命名规范
- 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）
- 变量名规范：首字母小写，后面每个大残首字母大写（小驼峰）
- 方法名规范：同变量名
常量&变量
常量：在程序运行期间，固定不变的量
常量的分类：
1、字符串常量：凡是用双引号引起来的部分，叫做字符串常量（可以不写字符）
2、整数常量：整数型
3、浮点数常量：有小数
4、字符常量：单引号引起来的部分（两个单引号之间必须要有内容，并且有且只能有一个字符）
5、布尔常量：true、false
6、空常量：null
public class constant {
public static void main(String[] args) {
//字符串常量
System.out.println("字符串常量：");
System.out.println("abc");
//-----------------------------------------------------------
System.out.println("整数常量：");
System.out.println(30);
System.out.println(-500);
//-----------------------------------------------------------
System.out.println("浮点数常量：");
System.out.println(3.14);
System.out.println(-1.5);
//-----------------------------------------------------------
System.out.println("字符常量：");
System.out.println('a');
// System.out.println('abc'); 只能有一个字符
// System.out.println(''); 单引号中必须要有内容
//-----------------------------------------------------------
System.out.println("布尔常量：");
System.out.println(true);
System.out.println(false);
//-----------------------------------------------------------
System.out.println("空常量：");
// System.out.println(null); 空常量不能直接打印输出
//-----------------------------------------------------------
}
}
public class constant {
public static void main(String[] args) {
//赋值操作
//整形
int a=5;
//字节型
byte b=1;
//短整形
short c=2;
//长整形最后以L收尾
long d=100000L;
//单精度浮点型最后以F收尾
float e=1.2F;
//双精度浮点型
double f=2.22;
//字符型
char g='g';
//布尔型
boolean o=true;
System.out.println(d);
}
}
数据类型转换
自动类型转换
特点：转化不需要代码声明，自动完成
规则：数据范围从小到大
public class dataType {
public static void main(String[] args) {
System.out.println();
long num1=100; //int转long
double num2=2.5F; //单精度浮点数转双精度浮点数
}
}
强制类型转换
可能发生精度损失，数据溢出
byte/short/char这三种类型都可以发生数学运算，列如+
byte/short/char这三种类型运算时都会被首先提升为int类型然后计算
boolean类型不能发生类型转换
long num13=(int)100; //long转int
ASC表
48=0
65=A
97=a
运算符
**运算符：**进行特定操作的符号
**表达式：**用运算符连起来的式子叫做表达式
“+”的三种用法
1、对于数值来说就是加法
2、对于char类型来说，在计算的时候会被升级为int类型，转换的关系可以参照表：ascii、unicode表
3、对于字符串string来说就是拼接操作
任何数据类型和字符串进行连接的时候，结果都会变成字符串
小括号中的内容是最优先执行的
自增自减运算符
++ 、–
区别前++和后++的区别
赋值运算符
比较运算符
逻辑运算符
与（并且） && 全是true才是true
或（或者） || 至少一个是true就是true，全是false才是false
非（取反） ！ 原来是true就变成false
三元运算符
方法入门
方法不能有嵌套包含关系
public class function {
//定义方法
public static void test1() {
System.out.println("我是方法test1");
}
public static void main(String[] args) {
//调用方法
test1();
}
}
流程控制
顺序结构
按顺序执行
判断语句
public class function {
//定义方法
public static void test1() {
int i=1;
if (i==2){
System.out.println("我是方法test1");
}else if (i==1){
System.out.println("成立");
}else {
System.out.println("不成立");
}
}
public static void test2() {
int a=20;
int b=30;
if (a>b){
System.out.println("最大值是："+a);
}else {
System.out.println("最大值是："+b);
}
int c=(a>b?a:b);
System.out.println("最大值是："+c);
}
public static void main(String[] args) {
//调用方法
test2();
}
}
选择语句
switch语句注意事项：
1、多个case后面的数值不可以重复
2、switch小括号中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举
3、switch语句灵活，前后顺序可以颠倒，
“匹配到case就从哪一个为止往下执行，直到遇到了break或者default为止
public static void test3(){
int a=1;
switch (a){
case 1:
System.out.println("你输入的是1");
break;
case 2:
System.out.println("最大值是2");
break;
default:
System.out.println("数据违法");
break;
}
}
循环语句
循环结构的基本组成部分，一般可以分为四个部分：
1、初始化语句：在循环开始最初执行，而且只能做唯一一次
2、条件判断：如果成立，循环继续；如果不成立，循环退出
3、循环体：重复要做的事情，若干语句
4、步进语句：每次循环后都要进行收尾
public class xunhuan {
public static void main(String[] args) {
//for
/*for(int i=0;i<10;i++){
System.out.println("你好！"+i);
}*/
//while
/* int i=1; //1、初始化
while (i<10){ //2、判断语句
System.out.println("你好"+i); //3、循环体
i++; //4、步进语句
}*/
//do while 会先执行do
int i=1;
int a=1;
do {
if (i%2==0){
a+=i;
}
i++;
}while (i<=100);
System.out.println(a);
}
}
break结束循环、continue跳出循环
for(int i=0;i<10;i++){
if (i==0){
continue; //跳出当前循环
}
if (i==9){
break; //结束循环
}
System.out.println("你好！"+i);
}
IDE的快捷键
shift+f6改变所有相关代码
方法详细
方法调用的三种格式
- 1、单独调用：方法名（参数）
- 2、打印调用：print（方法名（参数））
- 3、赋值调用：数量名 变量名称 =方法名称（参数）；
- void方法只能单独调用，不能进行打印调用或者赋值调用
package cn.function;
public class function1 {
//复习以前的方法
public static void test() {
for (int i=0;i<5;i++){
System.out.println("");
for (int j=0;j<20;j++){
System.out.print("*");
}
}
}
//方法调用的三种格式
/*
* 1、单独调用：方法名（参数）
* 2、打印调用：print（方法名（参数））
* 3、赋值调用：数量名 变量名称 =方法名称（参数）；
* void方法只能单独调用，不能进行打印调用或者赋值调用
* */
public static int test1(int a ,int b) {
int c=a+b;
return c; //返回的结果要与上面的数据类型相符
}
//求1-100之间所有数字的和值
public static int test2() {
int a=0;
for (int i=0;i<=100;i++){
a+=i;
}
return a;
}
//在主函数中调用方法
public static void main(String[] args) {
//1、
test1(3,2);
//2、
System.out.println(test1(3,2));
//3、
int e=test1(3,2);
System.out.println(e);
System.out.println(test2());
}
}
方法重载
方法的重载：多个方法的名称一样，但是参数列表不一样
好处：只需要记住一个方法名称，就可以实现类似的多个功能（会自动匹配参数列表）
因素：
【有关】
1、允许参数的个数不同
2、允许参数的类型不同
3、允许参数的多类型顺序不同
【无关】
1、与参数的传参名称无关
2、与方法的返回值无关（return）
package cn.function;
public class functionreboot {
public static int sum(int a,int b){
System.out.println("有两个方法执行");
return a+b;
}
public static int sum(int a,int b,int c){
System.out.println("有三个方法执行");
return a+b+c;
}
//允许参数数量不同
public static int sum(int a,int b,int c ,int d){
System.out.println("有四个方法执行");
return a+b+d;
}
//允许参数类型不同
public static boolean sum(short a,short b){
System.out.println("short方法执行");
if (a==b){
return true;
}else {
return false;
}
}
public static void main(String[] args) {
System.out.println(sum(10,20,30));
//生成60，有三个方法执行
System.out.println(sum((short) 10,(short) 20));
}
}
数组
数组的概念：是一种容器，可以同时存放多个数据值
数组的特点
1、数组是一种引用数据类型
2、数组中的多个数据类型必须统一
3、长度在程序运行期间不能改变
数组赋值与取值
package cn.function;
public class Array {
public static void main(String[] args) {
//动态初始化
//数据类型[]数组名称=new数据类型[数组长度]；
int [] arrayA =new int [300];
//静态初始化
//数据类型[]数组名称=new 数据类型[]{元素1，元素2，...}
int [] arrayB=new int[]{5,10,15,20};
//输出下标为1的数组对应的值
System.out.println(arrayB[1]);
//静态初始化省略格式
//数据类型[]数组名称={元素1，元素2，...}
int [] arrayC={11,22,33,44};
for (int i = 0; i < arrayC.length; i++) {
System.out.print(arrayC[i]+" ");
}
System.out.println();
//把数组中的某一个元素赋值给变量
int a=arrayC[1];
System.out.println(a);
System.out.println("=============");
//索引值赋值
int [] arrayD={11,22,33,44};
arrayD[0]=66;
arrayD[1]=77;
arrayD[2]=88;
arrayD[3]=99;
for (int i = 0; i < arrayD.length; i++) {
System.out.print(arrayD[i]+" ");
}
}
}
java内存
java的内存需要划分为5个部分
1、栈（Stack）
存放的都是方法中的局部变量。方法的运行一定要在栈当中。
局部变量：方法的参数，或者是方法{}内部的变量
作用域：一旦超出作用域，；立刻从栈内存中消失。
2、堆（Heap）
凡是new出来的东西，都在堆当中
堆内存里面的东西都有一个地址值：16进制
堆内存里的数据，都有默认值。规则：
| 如果是整数 | 默认为0 |
|---|---|
| 如果是浮点数 | 默认为0.0 |
| 如果是字符 | 默认为‘\u0000’ |
| 如果是布尔 | 默认为false |
| 如果是引用类型 | 默认为null |
3、方法区（Method Area）：存储.class相关信息，包含方法的信息。
4、本地方法栈（Native Method stack）：与操作系统相关
5、寄存器（pc Register）：与CPU相关
一个数组在内存中的表现
数组索引越界异常
表示索引写错了
Array indexout of bounds exception
数组空指针异常
如果不使用new或者只用null
null pointer exception（空指针异常）
常见的数组题
求一个数组最大值
int [] array=new int[]{5,10,15,20,25};
int a=array[0];
for (int i = 1; i < array.length; i++) {
if (array[i]>a){
a=array[i];
}
}
System.out.println(a);
把数组中所有的值倒序
int [] array=new int[]{5,10,15,20,25,30,35};
for (int i = 0; i<array.length; i++) {
int a=array[i]; //找到一个空值，用来倒手
array[i]=array[(array.length-1)-i]; //第一个值等于最后一个值
array[(array.length-1)-i]=a; //最后一个值等一第一个值
if(i==(array.length)/2-1){ //当前下标与后下标指向同一个元素时，表示全部轮询了一遍，这时应该跳出循环
break;
}
}
for (int i = 0; i < array.length; i++) { //输出数组所有值
System.out.println(array[i]);
}
方法二
数组在方法上的应用
数组作为方法的参数和返回值的时候，传递的都是地址值信息
package cn.function;
//数组作为方法的参数
public class functionArray {
public static void forArray(int[]array){ //设置方法，设置传参类型为数组
for (int i = 0; i < array.length; i++) {
System.out.print(array[i]+" ");
}
}
//数组作为返回值
//注意返回的值的类型一定要与定义方法的类型一样
public static int[] ret(int a,int b ,int c){
int sum=a+b+c;
int avg=sum/3;
int [] array={sum,avg};
return array;
}
public static void main(String[] args) {
int [] arrAy=new int[]{10,20,30,40,50};
forArray(arrAy); //调用方法
System.out.println("");
//调用返回值
int [] arr=ret(50,60,70);
System.out.println(arr[0]);
System.out.println(arr[1]);
}
}
面向对象和封装
面向过程：当需要实现一个功能的时候，每一个步骤都要你手动编写
面向对象：不关心过程，只在乎结果
package cn.function;
import java.util.Arrays;
public class object {
public static void main(String[] args) {
//面向过程
int [] array={50,60,70,80};
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i==array.length-1){
System.out.println(array[i]+"]");
}else {
System.out.print(array[i]+"，");
}
}
System.out.println("================");
//面向结果
System.out.println(Arrays.toString(array));
}
}
面向对象的三大特征：封装、继承、多态
类和对象
- 类是对一类事物的描述，是抽象的
- 对象是一类事物的实例，是具体的
- 类是对象的模版，对象是类的实体
成员变量是直接定义在类当中的，在方法外边（不能写在方法里面）
成员方法不要写static关键字
定义一个学生类
package cn.function;
//定义学生类
public class functionstudent {
//成员变量
String name;
int age;
//成员方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void study(){
System.out.println("学习");
}
}
调用这个学生类
package cn.function;
//1、导包：也就是指出需要使用的类在什么位置
//import 包名称.类名称
import cn.function.functionstudent;
//2、创建，格式
//类名 对象名 =new 类名称
/*3、使用，分为两种情况
* 使用成员变量：对象名.成员变量名
* 使用成员方法：对象名.成员方法名（参数）
* */
public class functionStudentRun {
public static void main(String[] args) {
//创建一个stu的变量
functionstudent stu=new functionstudent();
//使用成员变量：对象名.成员变量名
System.out.println(stu.name); //null
System.out.println(stu.age); //0
//改变对象中的成员变量数值内容
stu.name="张三";
System.out.println(stu.name); //张三
//调用成员对象方法： 对象名.成员方法名()
stu.eat();
}
}
练习–写一个phone的类
package cn.function;
/*
* 定义一个类：模拟手机这个事物
* 属性：品牌、价格、颜色
* 行为：打电话、发短信
*
* */
public class Phone {
//成员变量
String brand; //定义品牌
double price; //价格
String color; //颜色
//成员方法
public void call(String who){
System.out.println("给"+who+"打电话");
}
public void sendMessage(){
System.out.println("群发短信");
}
}
package cn.function;
//同一个文件下不用导包
import cn.function.Phone;
public class PhoneRun {
public static void main(String[] args) {
//根据Phone类创建一个对象
Phone one=new Phone();
one.brand="苹果";
one.price=8888.88;
one.color="黑色";
one.call("老王");
one.sendMessage();
}
}
在内存中体现
栈：先进后出
栈保存局部变量、堆保存参数、方法区保存方法
当两个引用指向同一个对象时（内存体现）
使用对象类型作为方法的参
package cn.function;
public class PhoneParam {
public static void main(String[] args) {
Phone one=new Phone();
one.brand="华为";
one.price=9999.99;
one.color="白色";
method(one);
}
public static void method(Phone param){
System.out.println(param.brand);
System.out.println(param.price);
System.out.println(param.color);
}
}
在内存中体现
使用对象类型作为方法的返回值
package cn.function;
public class PhoneReturn {
public static void main(String[] args) {
Phone two=returnPhone();
System.out.println(two.brand);
System.out.println(two.price);
System.out.println(two.color);
}
public static Phone returnPhone(){
Phone one=new Phone();
one.brand="华为";
one.price=9999.99;
one.color="白色";
return one;
}
}
在内存中的体现
成员变量和局部变量
封装
方法一
package cn.day424;
public class packaging {
public static int getMax(int[] array){
int ax=array[0];
for (int i = 0; i < array.length; i++) {
if (ax<array[i]){
ax=array[i];
}
}
return ax;
}
public static void main(String[] args) {
int[] array=new int[]{1,2,3,4,5,100};
int max= getMax(array);
System.out.println(max);
}
}
方法二
一旦使用上private后就能阻止其他类的直接访问，只能设置间接访问（使用set和get）。使用间接访问时可以写代码对传过来的参数做校验。
对于基本类型的boolean值，getter方法一定要改写成isXxx的形式，而setXxx规则不变
package cn.day424;
public class Person {
String name;
//一旦使用private后，本类可以访问；超出本类后不能直接访问
private int age;
public void show(){
System.out.println("我叫"+name+","+"年龄"+age);
}
// 间接访问private成员变量，就是定义一对getter/setter方法
// 这个成员方法，专用用于给age赋值；set需要有参数没返回
public void setAge(int num){
if (num<100 && num>0){
age=num;
}else {
System.out.println("非法数据");
}
}
// 专门用于获取age的数据；get没参数有返回
public int getAge(){
return age;
}
}
package cn.day424;
public class PersonRun {
public static void main(String[] args) {
Person person=new Person();
person.show();
person.name="张三";
// person.age=18; //当设置private后，直接访问会报错
// 使用间接访问
person.setAge(-18);
person.show();
}
}
this方法的使用
通过谁调用的方法谁就this
package cn.sj_java.day01.demon01;
/*
* 当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量
* 如果需要访问本类中的成员变量，需要使用this.成员变量名
* */
public class person {
String name;
public void sayHello(String name) {
System.out.println(name+"，你好，我是"+this.name);
}
}
package cn.sj_java.day01.demon01;
public class demon01 {
public static void main(String[] args) {
person one =new person();
one.name="张三";
one.sayHello("李四");
}
}
构造方法
package cn.sj_java.day01.demon01;
/*
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法
格式： public 类名称（参数类型 参数名称）
注意事项：
1、构造方法的名称必须和所在类名称完全一样，就连大小写也要一样
2、构造方法不要写返回值类型，连void都不写
3、构造方法不能return一个返回值
4、如果没有编写任何构造方法，那么编译器会默认送一个构造方法，没有参数、方法体什么事情都不做
public student(){}
5、一旦编写了一种以上的方法，编译器将不在赠送
6、构造方法也是可以进行重载的
重载：方法名称相同，参数列表不同
*/
public class student {
//成员变量
private String name;
private int age;
//无参数的构造方法
public student(){
System.out.println("无参构造方法执行了！");
}
//全参数的构造方法
public student(String name ,int age){
System.out.println("全参构造方法执行了！");
this.name=name;
this.age=age;
}
//getter setter
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
}
package cn.sj_java.day01.demon01;
public class demon02student {
public static void main(String[] args) {
student one =new student();
System.out.println("=====================");
student two =new student("张三",18);
System.out.println("姓名："+two.getName()+",年龄："+two.getAge());
two.setName("李四");
System.out.println("姓名："+two.getName()+",年龄："+two.getAge());
}
}
一个标准的类
这样标准的类也叫java Bean
利用ide自动生成getset代码
