关键字
关键字的特点:
- 完全小写的字母
- 在开发环境中有特殊颜色标记
标识符:
- 是指在程序中,我们自己定义的内容,比如类的名字,方法的名字和变量的名字等,都是标识符
命名规则:
- 标识符可以包含字母(区分大小写),0-9数字、美元符号和下划线_
- 标识符不能以数字开头
- 标识符不能是关键字
命名规范:
- 类名规范:首字母大写,后面每个单词首字母大写(大驼峰式)
- 变量名规范:首字母小写,后面每个单词首字母大写(小驼峰式)
- 方法名字规范:同变量名
常量(不可发生改变的量)
常量的分类:
- 字符串常量:凡使用双引号引起来的部分。例如“abc”
- 整数常量:直接写上的数字,没有小数点。例如89,7,
- 浮点型常量:直接写上的数字,有小数点。例如12.3
- 字符常量:凡是用单引号引起来的单个字符。例如’S’(
单引号之间必须有且只有一个字符
) - 布尔常量:只有两种取值,true或者false
- 空常量:null,代表没有任何数据 (空常量不能直接打印输出)
数据类型
- 基本数据类型:整数、浮点数、字符、布尔
- 引用数据类型:类、数组、接口
基本数据类型
数据类型 | 关键字 | 内存占用 |
---|---|---|
字节型 | byte | 1个字节 |
短整型 | short | 2个字节 |
整形 | int | 4个字节 |
长整型 | long | 8个字节 |
单精度浮点数 | float | 4个字节 |
双精度浮点数 | double | 8个字节 |
字符型 | char | 2个字节 |
布尔类型 | boolean | 1个字节 |
注意事项:
- 字符串是引用数据类型
- 浮点型可能只是一个近似值,并不是精确的值
- 数据范围与字节数不一定相关,例如float数据范围比long更加广泛,但是float是4字节,long是8字节
- 浮点数当中默认数据类型是double,如果一定要使用float类型,需要加上一个后缀F,如果是整数,默认是int类型,需要使用long类型,在后面加上L
变量(可以改变的量)
数据类型 变量名称 ;//创建一个变量
变量名称 = 数据值;//赋值
一步
数据类型 变量名称 = 数据值 ;
右侧数据值范围不能超过左侧数据类型的取值范围
注意:long 类型和float类型都要在结尾加上L或者F
数据类型转换
自动类型转换(隐式):
- 代码不需要特殊处理,自动完成
- 数据范围从小到大
- 数据范围从小到大是与字节数不相关的,byte<short<int<long<float<double
强制类型转换(显式):
- 数据范围大的数据转换为数据范围小的数据,需要强制类型转换,代码需要特殊的处理,不能自动完成
- 格式:范围小的类型 范围小的变量名 =(范围小的类型)原本范围大的数据;
- int num = (int) 100L;
**注意事项:**不推荐使用,可能会发生精度损失,数据溢出;
int num = (int) 600000000000L;//(数据超过int类型数据范围,发生数据溢出)
//double-->int
int num = (int) 3.5;//数据发生精度损失,这并不是四舍五入,所有的小数位置都会被舍弃掉
//输出的结果是3;
byte/short/char这三种类型都可以发生数学运算,例如加法"+"。(都会先提升为int类型,再进行运算);
char zifu1 = 'A';
System.out.println(zifu1+1);
//输出的是66,计算机底层都是二进制的,字符A,就是65
ASCll码(字符)
0——48
A——65
a——97
以此类推
运算符
算数运算符:
- 四则运算:加减乘除——+ - * / %(取模)
- 除法公式:被除数/除数 = 商。。。余数
- 对于整数表达式来说,除法是整除,结果仍然是整数,只看商,不看余数
- 只有对于整数的除法来说,取模运算符才有意义,取模就是只看余数,不看商
注意事项:一旦运算当中有不同类型的数据,那么结果将会是数据类型范围大的那种
四则运算符的三种用法:
- 对于数据来说,就只是加法
- 对于字符char来说,在计算之前,char会被提升为int类型,然后进行计算
- 对于字符串String来说,加号代表字符串的连接(任何数据类型和字符串类型进行连接,都会变成字符串类型)
- 小括号里面的优先执行
自增自减运算符
自增:++
自减:–
使用格式:写在变量名称之前,或者写在变量名称之后
使用方式:单独使用前++和后++没有任何区别
混合使用有重大区别:
- 前++,先+1,再使用
- 后++,先使用,后+1
自减运算符类似
注意:只有变量才能使用
赋值运算符
基本赋值:"=" 代表将右侧的数据交给左侧的变量
复合赋值:
- += a+=1 相当于 a=a+1
- -= b-=4 相当于 b=b-4
- /= c/=5 相当于 c=c/5
- %= d%=6 相当于 d=d%6
注意:
- 常量不能进行赋值
- 复合赋值隐式的添加了强制类型转换
比较运算符(布尔类型)
==
!=
true/false
注意:
- 进行多次判断时,不能进行连着写的
- 成立就是true,不成立就是false
逻辑运算符
与 | && | 全是true才是true,否则就是false |
---|---|---|
或 | || | 至少有一个是true就是true,双false就是false |
非 | ! | true就变成false,反之 |
与&&,或||,具有短路效果,如果左边已经可以判断的到最终结果,那么右边的代码就不再执行了,从而节省一定的性能
三元运算符
格式:数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
流程:首先判断条件是否成立
- 成立则为true,那么将表达式A赋值给变量
- 不成立则为false,那么将表达式B赋值给变量
int max;
int a =100;
int b = 200;
max = a > b ? a :b;
注意:三元运算符的结果必须得使用
必须同时保证表达式A和表达式B都符合左侧的数据类型的要求
方法入门
定义方法的格式
public static void 方法名称 (){
//方法体
}
方法名称的命名规则和变量一样,使用小驼峰式
方法的调用:
- 方法名称();
流程
判断语句
if(条件判断){
语句体
}
//条件判断为true则执行语句体,反之;
if(条件判断){
语句体1;
}else{
语句体2;
}
//根据条件判断来选择执行哪条语句体;
if(int num % 2 ==0){
//输出为偶数
}else{
//输出为奇数
}
if(判断条件){
执行语句1;
}else if(判断条件){
执行语句2;
}else{
执行语句3;
}
//n者选其一
//例子
int x = 10;
int y ;
if(x>=3){
y = 2*x+1;
}else if(-1<x&&x<3){
y=2*X;
}else{
语句体3;
}
//输出y
语句练习
package ifDome;
import com.sun.xml.internal.bind.v2.model.core.ID;
import java.util.Scanner;
public class Textif {
/**
*指定考试成绩,判断成绩等级
* 90-100 优秀
* 80-90 好
* 70-79 良
* 60-69 及格
* 60以下 不及格
*/
public static void main(String[] args) {
System.out.println("请输入你的成绩:");
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if (score<0||score>100){
System.out.println("你的成绩是错误的");
}else 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{
System.out.println("你的成绩是不及格");
}
}
}
private static void maxDome() {
//首先使用三元运算符
int a = 30;
int b = 20;
int max = a > b ? a : b;
System.out.println("最大值"+max);
//使用今天的if语句
if(a>b){
max = a;
}else {
max = b;
}
System.out.println("最大值"+max);
}
选择语句——Switch
注意事项:
- 多个case后面的数值不可以重复
- switch后面的括号当中只能是下列数据类型:基本数据类型:byte/short/char/int 引用数据类型:string字符串、enum枚举
- switch格式很灵活,前后顺序可以颠倒,break语句还可以省略
private static void switchDome() {
switch (表达式){//表达式是被检测量
case 常量值1:
语句体1;
break;
case 常量值2:
语句体2;
break;
case 常量值3:
语句体3;
break;
case 常量值4:
语句体4;
break;
default:
语句体n+1;
break;
}
}
例子
private static void switchDome() {
System.out.println("请输入数字:");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
switch (num) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你输入的有误");
break;
}
}
循环语句----for
循环结构的基本组成部分,四部分
- 初始化语句:在循环开始最初执行,只做唯一的一次
- 条件判断:如果成立,则循环继续,如果不成立,则循环退出
- 循环体:重复要做的事情内容,若干行语句
- 步进语句:每次循环之后都要进行的扫尾工作
for(初始化表达式;布尔表达式;步进表达式){
循环体;
}
while循环
while (条件判断){
循环体;
}
while循环扩展格式:
初始化语句
while(条件判断){
循环体;
步进表达式;
}
例子
private static void forDome() {
int i =1;
while (i<=100){
System.out.println("你干哈"+i);
i++;
}
}
do_while循环
do {
循环体;
} while(条件判断);
注意:while和后面加“;”
扩展 无条件执行第一次
初始化语句;
do{
循环体;
步进表达式;
}while (布尔表达式);
无脑执行第一次
do {
System.out.println("走来"+i);
i++;
}while (i<=10);
例子——1-100以内偶数的和
private static void sumDome() {
int sum =0;
for(int i =1;i<=100;i++){
if(i%2==0){
sum +=i;
}
}
System.out.println(sum);
}
三种循环的区别
- 如果条件判断从来没有满足过,那么for和while会执行0次,do_while会执行1次;
- for循环的变量在小括号中定义,只有在内部循环中才可以使用,while循环和do_while循环初始化语句本来就在外面,循环结束还可以继续使用;
break
可以用在switch语句中,一旦执行,整个switch语句立即结束
还可以用在循环语句中,一旦执行,整个循环语句立即结束,打断循环
循环的选择:
凡是次数确定的场景多用for循环,狗则多用while循环
continue
另一种是循环语句中的continue关键字
一旦执行,立即跳过当前次循环剩余内容,马上开始下一次的循环
private static void dome() {
for (int i = 1; i <= 10; i++) {
if(i==4){
continue;
}
System.out.println(i+"层到了");
}
}
死循环
永远停不下来的循环
循环的嵌套用法
private static void timeDome() {
for (int i = 0; i < 24; i++) {
//外层控制小时
for (int j = 0; j < 60; j++) {
//内层控制小时之内的分钟
System.out.println(i + "点" + j + "分");
}
}
}
IDEA项目结构
项目project
模块 model
包 package
package day04;
public class Dome01 {
/*定义方法
* public static void 方法名称(){
* 方法体;
* }
*
* 调用格式:
* 方法名称();
* */
/**
* 方法调用的注意事项:
* 方法定义的先后顺序无所谓
* 方法定义必须是挨着的,不能在一个方法的内部定义另外一个方法
* 方法定义后,自己不会主动执行,一定要方法的调用*/
public static void main(String[] args) {
forDome();
}
public static void forDome(){
for (int i = 0; i < 5; i++) {
for (int j = 0; j < 20; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
方法的调用
package day04;
/*方法就是若干语句的集合
*
* 方法就好像一个工厂
*
* 原料:
* 产出物:
* 参数(原料),就是进入方法的数据
* 返回值(产出物),就是从方法中出来的数据
*
* 定义方法的基本格式:
* 修饰符 返回值类型 方法名称(参数类型 参数名称....){
* 方法体
* return 返回值;
* }
*
* 修饰符:现阶段的固定写法,public static
*
* 返回值类型:也就是方法最终产生的数据结果是什么类型
* 方法名称:方法的名字,规则和变量一样,小驼峰
* 参数类型:进入方法的数据类型
* 参数名称:就是进入方法的变量
*
* 参数如果有多个 需要用逗号分隔
* return:停止当前的方法,将后面的结构数据返回给调用处
* 返回值:方法执行后产生的数据结果
*
* 注意:return的返回值类型,必须与方法名称前面的返回值类型,保持对应
*
* 方法的三种调用格式:
* 单独调用:方法名称(参数);
* 打印调用
* 赋值调用
*
* 注意:此前学习的方法 返回值类型为void,这种方法只能通过单独调用
* */
public class Dome02 {
public static void main(String[] args) {
//单独调用
sum(10,20);
System.out.println("=====================");
//打印调用
System.out.println(sum(10,20));
System.out.println("=====================");
//赋值调用
int num = sum(10,80);
System.out.println("变量的值"+num);
}
public static int sum(int a, int b) {
int result = a + b;
return result;
}
}
有参无参的区别
package day04;
/*
* 有参数:小括号中有内容,一个方法需要一些数据条件才能完成任务
* 无参数:不需要任何数据就能完成,自己可以独立完成
* */
public class Dome03 {
public static void main(String[] args) {
method01(10,60);
method02();
}
//俩个数字相乘,必须知道两个数据都是多少,否则无法计算
public static void method01(int a,int b){
int result =a*b;
System.out.println("结果是"+result);
}
//打印十次字符串
public static void method02(){
for (int i = 0; i < 10; i++) {
System.out.println("你好啊");
}
}
}
对比有返回值和没有返回值
public class Back {
/*题目要求:定义一个方法,用来求出两个数字之和,计算完成之后将返回值结果告诉我
* 题目变形:定义一个方法,用来打印两个数字之和,自己计算 直接打印*/
public static void main(String[] args) {
int sum = getSum(10, 20);
System.out.println(sum);
}
//我是一个方法,负责计算两个数字相加,我有返回值,谁调用我 我就将结果告诉谁
public static int getSum(int a, int b) {
int result = a + b;
return result;
}
//无返回值,直接打印
public static void printSum(int a, int b) {
int result = a + b;
System.out.println(result);
}
}
注意事项:
- 对于有返回值的方法,可以使用单独调用,打印调用和赋值调用
- 对于无返回值的方法,只能使用单独调用,不能使用打印调用或者赋值调用
使用方法的注意事项:
- 方伐应该定义在类当中,但是不能在方法当中再定义方法,不能嵌套
- 方法定义的先后顺序无所谓
- 方法定义之后不会执行,如果希望执行,一定要调用,单独调用,赋值调用,打印调用
- 如果方法有返回值,那么必须写上“return” 返回值;不能没有
- return的返回值数据,必须和方法的返回值类型对应起来
- void 没有返回值类型的方法,不能写return数据,只能写个return
- 对于方法最后一行的return可以省略不写,有返回值的必须写
- 一个方法当中可以有多个return语句,但是必须保证同时只有一个会被执行到,两个不能连写
方法的重载(overload)
功能类似的方法,参数相似,就可以用方法的重载
方法的名称相同,参数列表不同
好处:只需要记住一个方法名称,就可以实现多个类似的功能
方法重载与下列因素相关:
- 参数个数不同
- 参数类型不同
- 参数多类型顺序不同
参数重载与下列因素无关:
- 参数名称无关
- 与方法的返回值类型无关
数组的概念
数组的特点:
- 数组是引用数据类型
- 数组中的多个数据类型必须统一
- 数组的长度在程序运行期间不可改变
数组的初始化:在内存中创建一个数组,并且向其中赋予一些默认值
两种常见的初始化方式:
- 动态初始化(指定长度)
- 静态初始化(指定内容)
动态初始化格式:
数据类型[] 数组名称 = new 数据类型[数组长度];
静态初始化省略格式:
数据类型[] 数组名称 = {元素1, 元素2,元素3…};
注意事项:
- 静态初始化可以拆分为两个步骤
- 静态初始化没有指定数组长度,但是仍然会自动推算得到的长度
- 动态初始化也可以拆分为两个步骤
- 静态初始化省略格式就不可以拆分为两个步骤
int[] arrayA = new int[3];//动态数组
int[] arrayB ={1,2,3,4};//静态数组
访问数组元素的格式:
- 数组名称[索引值]
- 索引值 就是一个int类型,代表数组当中的元素编号
- 注意:索引值是从0开始的,一直到 数组的长度-1 为止
初始化数组的时候,其中的元素会自动拥有一个默认值,规则如下:
- 整数类型 0
- 浮点类型 0.0
- 字符类型 ‘\u0000’
- 布尔类型 false
- 引用类型 null
//将123赋值给array中的一号元素
array[1] = 123;
数组索引越界异常
数组索引编号是从0开始的,一直到 数组的长度-1 为止
如果访问数组元素的时候,索引编号并不存在,那么将会发生数组索引越界异常
常见问题
空指针异常NullPointerException
数组没有初始化,数组可以初始化为null,因为数组是引用类型
如果只赋值了null,没有进行new创建,那么会发生空指针异常
如何获取数组的长度
静态初始化获取数组长度——数组.length
int len = arrayA.length;//数组一旦创建,运行期间,数组长度不可改变
数组打印输出的API
String[] array = {"贾乃亮","陈羽凡","王宝强"};
//打印数组内容的Api是Arrays.toString(array)
System.out.println(Arrays.toString(array));
//遍历数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
数组的遍历输出:就是对数组的每一个元素进行打印输出
/*数组的遍历输出*/
public static void main(String[] args) {
int[] arrayA = {1, 2, 3, 4, 55, 66, 77};
//使用循环
for (int i = 0; i < arrayA.length; i++) {
System.out.println(arrayA[i]);
}
}
例子:求出最值
/*求出最值*/
public class Dome02 {
public static void main(String[] args) {
int[] array ={10,5,15,20,30,60};
int max =array[0];
for (int i = 0; i < array.length; i++) {
//如果当前元素比max更大,那就换人
if(array[i]>max){
max = array[i];
}
}
System.out.println("最大值是:"+max);
}
}
数组元素反转
package dome01;
/*数组元素的反转
* 本来的样子{1,2,3,4}
* 反转之后{4,3,2,1}*/
//要求:不能使用新数组
//数序元素的反转 就是对称元素的交换
public class Dome03 {
public static void main(String[] args) {
//最简单的数组元素反转
int[] array = {1, 22, 33, 44, 55};
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
System.out.println("=======================");
/*初始化语句:int min = 0,int max = array.length-1;
* 条件判断:min<max
* 步进语句:min++,max--*/
for (int min = 0, max = array.length - 1; min < max; min++, max--) {
int temp = array[min];
array[min] = array[max];
array[max] = temp;
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
数组作为方法的参数
当调用方法的时候,向方法的小括号进行传参,传递进去的其实是数组的地址值。
如果希望一个方法的返回值当中产生多个结果数据进行返回,怎么办?
解决方案:使用一个数组作为返回值类型即可。
package dome01;
public class Dome04 {
public static void main(String[] args) {
int[] result =calculate(1,2,3);
System.out.println("总和是"+result[0]);
System.out.println("平均值是"+result[1]);
}
public static int[] calculate(int a ,int b, int c){
int sum =a+b+c;
int avg =sum/3;
int[] array = {sum,avg};
return array;
}
}
面向对象
当需要的实现一个功能时,不关心具体步骤,而是找到一个已经拥有该功能的人,来帮助我做事
package ifDome;
import java.util.Arrays;
public class Dome01 {
public static void main(String[] args) {
int[] array = {1,3,5,66,545,88,44};
/*要求打印格式为:[1,3,5,66,545,88,44]*/
//使用面向过程的方法
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if(i==array.length-1){
System.out.print(array[i]+"]");
}else{
System.out.print(array[i]+",");
}
}
System.out.println("=================");
//使用面向对象的方法
System.out.println(Arrays.toString(array));
}
}
- 使用面向对象
- 找一个JDK给我们提供好的Array类
- 其中有一个toString 方法,直接就能把数组变成想要的格式的字符串
面向对象的三大特征:
封装、继承、多态
package ifDome;
/*
* 定义一个类,就是模拟学生事物,其中有两个组成部分
*
* 属性:是什么
* 姓名
* 年龄
* 行为:能做什么
* 吃饭
* 睡觉
* 学习
*
*
* 成员变量:姓名 年龄
* 成员方法:吃饭 睡觉 学习*/
/*
* 注意事项:
* 成员变量是直接定义在类当中的,在方法的外边
* 成员方法不要写static 关键字*/
public class Student {
//成员变量
String name;
int age;
//成员方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void study(){
System.out.println("学习");
}
}
创建对象 使用成员变量 和成员方法
package ifDome;
/*通常情况下,一个类不能直接使用,需要根据类创建一个对象,才能使用
*
* 创建格式:
* 类名称 对象名称 = new 类名称();
*
* 使用:分两种情况
* 使用成员变量:对象名称.成员变量名
* 使用成员方法:对象名称.成员方法名()_想用谁就对象名.谁
* */
public class Dome02Student {
public static void main(String[] args) {
Student student = new Student();
//使用成员方法
student.eat();
student.sleep();
student.study();
//使用成员变量
//将右面的字符串赋值给左边的成员变量
student.name = "赵丽颖";
student.age = 18;
System.out.println(student.age);
System.out.println(student.name);
}
}
注意事项:如果成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样
改变对像当中的成员变量内容
内存中分为五块区域:
- 栈stack
- 堆heap
- 方法区method area
使用对象类型作为方法的参数
public class Dome02PhoneParam {
public static void main(String[] args) {
Phone one = new Phone();
one.name ="苹果";
one.color ="红色";
one.price =15.5;
//调用方法
method(one);
}
public static void method(Phone co){
System.out.println(co.name);
System.out.println(co.color);
System.out.println(co.price);
}
}
注意事项:当一个对象作为参数,传递到方法中去,实际上传递进去的是对象的地址值
使用对象类型作为方法的返回值类型
public class Dome02PhoneReturn {
public static void main(String[] args) {
Phone two = getPhone();
System.out.println(two.name);
System.out.println(two.price);
System.out.println(two.color);
}
//返回值类型是对象类型
public static Phone getPhone(){
Phone one = new Phone();
one.price = 15.2;
one.color ="玫瑰金";
one.name ="苹果";
return one;
}
}
成员变量和局部变量的区别
/*局部变量和成员变量
* 1.定义的位置不一样(重点)
* 成员变量:方法的外部,直接写在类当中
* 局部变量:在方法的内部
*
* 2.作用域不一样
* 局部变量:只有在方法内使用,出了方法就失效
* 成员变量:在整个类中都可以使用
*
* 3.默认值不一样(重点)
* 局部变量:没有默认值,想使用,先赋值
* 成员变量:有默认值
*
* 4.内存的位置不一样(了解)
* 局部变量:位于栈内存
* 成员变量:位于堆内存
*
* 5.生命周期不一样(了解)
* 局部变量:随着方法进栈而诞生,随着方法出栈而消失
* 成员变量:随着对象创建而诞生,随着对象被垃圾回收而消失*/
注意事项:
- 局部变量想要使用,必须先赋值
- 方法的参数就是局部变量
- 参数在方法的调用时,必然会被赋值的
封装性
- 方法就是一种封装
- 关键字private也是一种封装
封装就是将一些细节信息隐藏起来,对于外界不可见
一旦使用private进行修饰,本类当中还是可以随意访问,但是,超出部分就无法直接访问了。
间接访问private成员变量,就是定义一对getter/setter方法
必须叫setXxx或者getXxx命名规则
对于getter来说,不能有参数,返回值类型和成员变量类型对应
对于setter来说,不能有返回值,参数类型和成员变量类型对应
public int getAge() {
return age;
}
//这个成员方法专用于向age设置数据
public void setAge(int age) {
//在这里边进行条件的判断
this.age = age;
}
this关键字的作用
- 当方法的局部变量和类的成员变量重名的时候,根据就近原则,优先使用局部变量
- 如果需要访问本类中的成员变量,需要使用格式:this.成员变量
通过谁调用的方法,谁就是this
构造方法
是用来创建对象的方法,当我们通过关键字new来创建对象的时候,其实就是在调用构造方法
格式:public 类名称(参数类型 参数名称){
方法体
}
注意事项:
-
构造方法的名称必须和所在的类名称完全一样,就连大小写也要一样;
-
构造方法不要写返回值类型,连void都不要写
-
构造方法不能return一个具体的返回值
-
如果没有编写任何构造方法,那么编译器赠送一个构造方法,没有参数,方法提什么事情也不做
-
一旦编写了至少一个,编译器不再赠送
-
构造方法也是可以进行重载的
重载:方法名称相同,参数列表不同
java Bean
/*一个标准的类通常要拥有以下四个组成部分 * * 1.所有的成员变量都要使用private关键字修饰 * 2.为每一个成员变量编写一对getter/setter方法 * 3.编写一个无参数构造方法 * 4.编写一个全参数构造方法 * * 这样的标准的类也叫做 java Bean*/ public class Student { private String name;//姓名 private int age;//年龄 public Student(String name, int age) { this.name = name; this.age = age; } public Student() { } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }
常用的API
Scanner类
package dome04;
import java.util.Scanner;
/*Scanner类,可以实现键盘录入数据,到程序当中
*
* 引用类型的一般使用步骤
*
* 只用java.lang包下的内容不需要导包,其他的包都需要import语句
* */
public class Dome04Scanner {
public static void main(String[] args) {
System.out.println("请输入数字:");
//备注:System.in就是从键盘输入
Scanner sc = new Scanner(System.in);
//获取键盘输入的字符串string s = sc.next();
int num = sc.nextInt();
System.out.println("输入的键盘数字是" + num);
//获取键盘输入的字符串
String str = sc.next();
System.out.println("输入的字符串是"+str);
}
}
练习题目:键盘输入两个int类型数字计算相应的和;
import java.util.Scanner;
/*题目:键盘输入两个int数字,求和
*思路:*/
public class Dome04SUm {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入数字a:");
int a = sc.nextInt();
System.out.println("请输入数字b:");
int b = sc.nextInt();
int result = a + b;
System.out.println("结果是"+result);
}
}
package dome04;
import java.util.Scanner;
/*键盘输入三个数字,求出其中的最大值*/
public class Dome04Max {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个数字:");
int a = sc.nextInt();
System.out.println("请输入第二个数字:");
int b = sc.nextInt();
System.out.println("请输入第三个数字:");
int c = sc.nextInt();
//首先得到前两个数字中的最大值
int temp = a > b ? a : b;
int max = temp > c ? temp : c;
System.out.println("最大值是"+max);
}
}
匿名对象 eg: new Person(); 就是直接new出来的
注意事项:只能使用一次,下次再用不得不创建一个新对象
使用建议:如果确定一个对象只使用一次,就可以用匿名对象
匿名对象作为参数的返回值和参数
package dome04;
import java.util.Scanner;
public class Dome {
public static void main(String[] args) {
/*//普通方式
Scanner sc = new Scanner(System.in);
System.out.println("请输入数字:");
int s = sc.nextInt();
System.out.println("输入的数字是"+s);
//匿名对象方式
int a = new Scanner(System.in).nextInt();
System.out.println("输入的数字是"+a);
*/
//使用匿名对象进行传参
getMethod(new Scanner(System.in));
}
public static void getMethod(Scanner sc){
int sun = sc.nextInt();
System.out.println("输出的是"+sun);
}
}
Random类
package dome04;
/*使用:
* 获取一个随机的int数字(范围是int的所有范围,有正负两种)
* 获取一个随机的int数字(参数代表了范围,左闭右开区间)
* int nun = r.nextInt(3);
* 实际含义就是0-2*/
import java.util.Random;
import java.util.function.DoubleToIntFunction;
public class Dome04Random {
public static void main(String[] args) {
int n =5;
Random r = new Random();
//本来的范围是【0,n),整体+1之后就是【1,n】
int result = r.nextInt(n) + 1;
System.out.println(result);
}
}
猜数字小游戏
package dome04;
import java.util.Random;
import java.util.Scanner;
/*猜字小游戏
* */
public class Dome04Guss {
public static void main(String[] args) {
Random r = new Random();
int resultNum = r.nextInt(100)+1;
Scanner sc = new Scanner(System.in);
while (true){
System.out.println("请输入你猜测的数字");
int gussNum = sc.nextInt();
if(gussNum>resultNum){
System.out.println("太大了,请重试");
}else if(gussNum<resultNum){
System.out.println("太小了,请重试");
}else {
System.out.println("恭喜你,猜对了");
break;
}
}
System.out.println("游戏结束!!!");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-awy2h0Pf-1600214604321)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911074708713.png)]
对象数组
任何数据类型都可以作为数组的类型
**缺点:**一旦创建,程序运行期间长度不可改变
数组的长度是不可以改变的,但是ArrayList长度是可以改变的
ArrayList 泛型
ArrayList的常用API
package dome04;
import java.util.ArrayList;
import java.util.List;
/*对于ArrayList集合来说,add添加动作一定是成功的*/
public class Dome04ArrayLit {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
System.out.println(arrayList);//[]
//向集合中添加元素
arrayList.add("赵丽颖");
arrayList.add("赵又廷");
System.out.println(arrayList);//[赵丽颖, 赵又廷]
//从集合中获取元素:get.索引值从0开始
String name = arrayList.get(0);
System.out.println("第一号索引位置"+name);//第一号索引位置赵丽颖
//从集合中删除元素remove
String whoRemove = arrayList.remove(0);
System.out.println(arrayList);//[赵又廷]
int size =arrayList.size();
System.out.println("集合的长度是"+size);//集合的长度是1
}
}
遍历集合ArrayList
package dome04;
import java.util.ArrayList;
import java.util.Arrays;
//遍历ArrayList集合
public class Dome04For {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("李小璐");
list.add("白百合");
list.add("马蓉");
System.out.println(list);
String[] array = {"贾乃亮","陈羽凡","王宝强"};
//打印数组内容的Api是Arrays.toString(array)
System.out.println(Arrays.toString(array));
//遍历数组
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
//遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ShHRgs7U-1600214604330)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911092919085.png)]
泛型只能是引用数据类型
基本类型 | 包装类 |
---|---|
byte | Byte |
short | A |
int | Integer【特殊】 |
long | Long |
float | Float |
double | Double |
char | Character【特殊】 |
boolean | V |
package dome04;
import java.util.ArrayList;
import java.util.Arrays;
/*泛型只能是引用数据类型
*
* 向ArrayList集合中存储基本数据类型就必须使用相应“包装类”
* */
public class Dome04Basic {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
list.add(3);
list.add(9);
list.add(222);
System.out.println(list);
System.out.println(list.get(2));
}
}
题目:生成1-33之间的6个随机数字,将他们加入到集合中去,进而遍历集合
package dome04;
import java.util.ArrayList;
import java.util.Random;
/*题目:生成6个1——33之间的随机整数,添加到集合,并遍历集合
* 思路:
* 需要循环6次产生6个随机数字,for循环
* 随机数字是random,1-33是有参数的获得
* 循环的每一次将得到的随机数字加入到集合中去
* 最后遍历集合*/
public class Dome01 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 6; i++) {
int num = r.nextInt(33)+1;
list.add(num);
}
System.out.println(list);
//遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
运行效果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nwNskHlf-1600214604332)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911094759629.png)]
自定义类型充当泛型
package dome04;
public class People {
private String name;
private int age;
public People(String name, int age) {
this.name = name;
this.age = age;
}
public People() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return name+age;
}
}
package dome04;
import java.util.ArrayList;
public class Dome02 {
public static void main(String[] args) {
ArrayList<People> list = new ArrayList<>();
list.add(new People("江富道",23));
list.add(new People("孙诗博",24));
list.add(new People("李斯文",23));
list.add(new People("刘勇许",22));
System.out.println(list);
//遍历集合
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i).getName()+list.get(i).getAge());
}
}
}
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sIIRpuEv-1600214604336)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911095901536.png)]
指定格式遍历集合字符串
package dome04;
import java.util.ArrayList;
/*将ArrayList集合按照自定义格式打印出来*/
public class Dome03 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("张翠山");
list.add("张无忌");
list.add("张丹峰");
list.add("张留生");
//默认样式
System.out.println(list);
//自定义样式
System.out.print("{");
for (int i = 0; i < list.size(); i++) {
if(i==list.size()-1){
System.out.print(list.get(i)+"}");
}else{
System.out.print(list.get(i)+"@");
}
}
}
}
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sURT2bYy-1600214604339)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911113607456.png)]
题目:用一个大集合存储20个随机数字,然后筛选其中的偶数元素,放到小集合当中。
要求使用自定义的方法来实现筛选
package dome04;
import javax.swing.text.StyleContext;
import java.util.ArrayList;
import java.util.Random;
/*用一个大的集合存入20个随机数字,然后筛选其中的偶数元素,放到小集合当中去
* 要求自定义方法来实现筛选*/
public class Dome04 {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Random r = new Random();
for (int i = 0; i < 20; i++) {
int num = r.nextInt(100) + 1;
list.add(num);
}
System.out.println(list);
ArrayList<Integer> smallList = getSmallList(list);
System.out.println(smallList);
//遍历小集合的元素
for (int i = 0; i < smallList.size(); i++) {
System.out.println(smallList.get(i));
}
}
//这个方法接受大集合参数,返回小集合
public static ArrayList<Integer> getSmallList(ArrayList<Integer> list) {
//创建一个小集合,用来装偶数
ArrayList<Integer> smallList = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
int num = list.get(i);
if (num % 2 == 0) {
smallList.add(num);
}
}
return smallList;
}
}
字符串的概述和特点
package dome05;
/*程序中所有的双引号的面值都是字符串
* 字符串一旦创建不能改变
* 字符串的底层就是用的byte字节数组
*
* 创建字符串的三种方法
* public String()创建一个空白字符串,不含任何内容
* public String(char[] array)根据字符数组的内容,来创建相应的字符串
* public String(byte[] array)根据字节数组的内容,来创建相应的字符串
*
* 一种直接创建:
* 注意:直接写上双引号,就是字符串的对象
*
* */
public class Dome01 {
public static void main(String[] args) {
//使用空参构造
String str1 = new String();//小括号留空,说明字符串什么内容都没有
System.out.println("第一个字符串的内容是"+str1);
//根据字符数组创建
char[] array = {'A','B','C'};
String str2 = new String(array);
System.out.println("第二个字符串是"+str2);
//根据字节数组创建
byte[] bytearray = {97,98,99};
String str3 = new String(bytearray);
System.out.println("第三个字符串的内容是"+str3);
//直接创建
String str4 = "你是谁";
}
}
运行结果是
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yi9FndVB-1600214604341)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200911151852996.png)]
字符串从常量池
程序中直接写上的双引号字符串,就是在字符串常量池中
字符串常量池在堆当中
字符串常用方法
任何对象都能用object接收
public boolean equals(Object obj)
package dome05;
import com.sun.xml.internal.ws.message.stream.StreamHeader12;
/**/
public class Dome03 {
public static void main(String[] args) {
//获取字符串的长度
int length = "aaifiefjawhfiowejfa".length();
System.out.println("字符串的长度是"+length);
//拼接字符串
String str1 ="Hello";
String str2 ="World";
String str3 =str1.concat(str2);
System.out.println(str1);//原封不动
System.out.println(str2);//原封不动
System.out.println(str3);//拼接的新字符串
//获取指定索引位置的字符
char ch = "Hello".charAt(1);
System.out.println("一号索引位置的字符是"+ch);
//查找参数字符串在本来字符串当中出现的第一次索引位置
String a = "HelloWorld";
int index = a.indexOf("llo");
System.out.println("第一次索引值是"+index);
//如果根本没有 返回-1值
System.out.println("hhh".indexOf("abc"));
}
}
字符串的截取方法
package dome05;
import org.omg.CORBA.ARG_OUT;
//字符串的截取,包含左边不包含右边
public class Dome04 {
public static void main(String[] args) {
String str = "HelloWorld";
String str1 = str.substring(5);
System.out.println(str1);//新字符串
String str2 = str.substring(4,7);
System.out.println(str2);
//只是地址值改变了,但是字符串常量是不可改变的
String a = "hello";
System.out.println(a);
a="world";
System.out.println(a);
}
}
String字符串相关转换方法
package dome05;
/*String当中与转换相关的方法有
*
* public char[] toCharArray(),将当前字符串拆分成为字符数组作为返回值
*
* public byte[] getBytes(),获取字符串底层的字节数组作为返回值
*
* 字符串的内容的替换repalce("字符","新字符")*/
public class Dome05 {
public static void main(String[] args) {
//将字符串转换成字符数组
char[] chars ="Hello".toCharArray();
//遍历字符数组
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
System.out.println("===================");
//将字符串转换成字节数组
byte[] bytes = "abc".getBytes();
//遍历字节数组
for (int i = 0; i < bytes.length; i++) {
System.out.println(bytes[i]);
}
System.out.println("===================");
//替换原来的字符串的字符进而输出新的字符串
String result = "How do you do?";
String dome = result.replace("o", "*");
System.out.println(result);//原来的字符串
System.out.println(dome);//新的字符串
}
}
分隔字符串
package dome05;
/*分割字符串的方法:
* public String[] split(String[] args)
*
* 注意事项:split方法的参数是一个正则表达式
* 如果按照英文句点进行分隔进行分隔需要加\\.*/
public class Dome06 {
public static void main(String[] args) {
String str1 = "aaa,bbb,ccc";
//以“,”为标志进行分隔
String[] array1 = str1.split(",");
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
System.out.println("============");
String a = "xxx.yyy.zzz";
String[] array = a.split("\\.");
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
按指定格式拼接字符串
package dome05;
/*按指定格式拼接字符串
*
* 题目:定义一个方法,把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下:【Word1#word2#Word3】*/
public class Dome07 {
public static void main(String[] args) {
int[] array1 = {1, 2, 3};
System.out.println(fromStringToArray(array1));
}
public static String fromStringToArray(int[] array) {
String str = "[";
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
str += "word" + array[i] + "]";
} else {
str += "word" + array[i] + "#";
}
}
return str;
}
}
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q7yeoAew-1600214604345)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912081550512.png)]
题目:键盘输入字符串统计各种字符出现的次数
package dome05;
import java.util.Scanner;
/*题目:键盘输入一个字符串,统计其中各种字符出现的次数
* 种类有:大写字母、小写字母、数字、其他
*
* 思路:
* 键盘输入Scanner
* 字符串sc.next()
* 定义四个变量分别代表四种字符出现的次数
* 对字符串进行检查,方法是toCharArray()
* 遍历char[]字符数组,对当前字符的种类进行判断,且用四个变量进行++动作
* 打印四个变量 显示各种字符出现的次数
* */
public class Dome08 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String input = sc.next();
int countUpper =0;//大写字符
int countLower =0;//小写字符
int countNumber =0;//数字
int countOther =0;//其他字符
char[] chars = input.toCharArray();
for (int i = 0; i < chars.length; i++) {
char ch =chars[i];//当前每个字符
if('A'<=ch&&ch<='Z'){
countUpper++;
}else if('a'<=ch&&ch<='z'){
countLower++;
}else if('0'<=ch&&ch<='9'){
countNumber++;
}else{
countOther++;
}
}
System.out.println("大写字符个数是"+countUpper);
System.out.println("小写字符个数是"+countLower);
System.out.println("数字字符个数是"+countNumber);
System.out.println("其他字符个数是"+countOther);
}
}
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hrjU7QRU-1600214604346)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912083155230.png)]
Static关键字使用
静态static关键字修饰成员变量
package dome05;
public class Student {
private String name;
private int age;
private static int countId = 0;//让id在每一次创建对象的时候都顺序递增
private int id;
static String room;//static修饰的静态成员变量,是属于类本身的
public Student(String name, int age) {
this.name = name;
this.age = age;
this.id = ++countId;//递增
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Student() {
this.id = ++countId;//递增
}
}
测试类
package dome05;
/*
* 如果一个成员变量使用了static关键字,那么这个成员变量就属于类*/
public class Dome09 {
public static void main(String[] args) {
Student a = new Student("江富道",18);
a.room="过控1703";
System.out.println("姓名是"+a.getName()+",年龄是"
+a.getAge()+",班级是"+a.room+",id是"+a.getId());
Student b = new Student("牛结实",22);
System.out.println("姓名是"+b.getName()+",年龄是"
+b.getAge()+",班级是"+b.room+",id是"+b.getId());
}
}
运行结果是
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gWcKGR1Y-1600214604348)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912091454332.png)]
静态关键字修饰成员方法,就是静态方法,属于类
如果没有static关键字就是实例方法,需要创建对象,才能使用它
无论是成员变量还是成员方法都推荐使用类名称.成员变量/成员方法来调用
注意事项:
- 在本类当中调用静态,可以省略类名称
- 静态不能访问非静态(静态方法不可以访问非静态内容)
- 静态方法当中不能使用this,this代表哪个对象调用的
注意:根据类名称访问静态成员变量,跟对象没任何关系
静态代码块
格式:
$$
public class 类名称{
static{
语句体;
}
}
$$
特点:当第一次用到本类时,静态代码块执行唯一的一次
静态内容总是优先于非静态的,静态代码块优先于构造方法
典型用途:
用来一次性的对静态成员变量进行赋值
数组工具类Arrays
说明:数组工具类的常用方法
package dome05;
/*数组工具类Arrays
*
* 将数组转成字符串类型(默认)Arrays.toString(数组名称)
*
* 将数组按照默认升序的方式进行排序,是void 类型,无返回值,Arrays.sort(数组名称)*/
import java.util.Arrays;
public class Dome010 {
public static void main(String[] args) {
int[] array = {10,20,30};
//将int[]数组按照默认格式转成字符串
String str = Arrays.toString(array);
System.out.println(str);
System.out.println("=========");
//按照默认升序对数组元素进行排序
int[] array1 ={48,15,236,88,44,255,11,1};
//排序,void类型,没有返回值
Arrays.sort(array1);
System.out.println(Arrays.toString(array1));
System.out.println("=================");
//如果是字符串类型的数组,按照字母升序排列
//如果是自定义类型,那么这个自定义的类需要有Comparable或者Comparator接口的支持
String[] array3 = {"bbb","ccc","aaa"};
Arrays.sort(array3);
System.out.println(Arrays.toString(array3));
}
}
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vHYgZlQ5-1600214604350)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912100643898.png)]
练习题目:
请使用Arrays相关API,将一个随机字符串的所有字符串升序排列,并倒序打印
package dome07;
import java.util.Arrays;
import java.util.Scanner;
/*键盘输入一个字符串,将字符串中的字符按升序排列,然后倒序打印*/
public class Dome01 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个随机字符串:");
String str = sc.next();
//将字符串转换成字符数组
char[] charArray = str.toCharArray();
Arrays.sort(charArray);
System.out.println(charArray);//升序排列的数组
System.out.println("=======");
//倒序打印
for (int i = charArray.length - 1; i >= 0; i--) {
System.out.println(charArray[i]);
}
}
}
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PnaIyNNp-1600214604352)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912101841827.png)]
数学工具类Math
package dome07;
/*public static boolean abs(double num),获取绝对值
* public static boolean ceil(double num),向上取整
* public static boolean floor(double num),向下取整
* public static boolean round(double num).四舍五入
*
* */
public class Dome02 {
public static void main(String[] args) {
//获取绝对值
System.out.println(Math.abs(-1));
System.out.println(Math.abs(0));
//向上取整
System.out.println(Math.ceil(3.4));
//向下取整
System.out.println(Math.floor(3.9));
//四舍五入
System.out.println(Math.round(3.5));
}
}
运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YZfIY66O-1600214604354)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912104416313.png)]
练习题
package dome07;
/*计算在-10.8到5.9之间,绝对值大于6或者小于2.1的整数有多少个*/
public class Dome03 {
public static void main(String[] args) {
int count =0;//符合要求的数量
double min = -10.8;
double max = 5.9;
//这样处理,变量i就是区间之内的所有整数
for(int i = (int)min;i<max;i++){
int abs = Math.abs(i);
if(abs>6||abs<2.1){
System.out.print(i+",");
count++;
}
}
System.out.println();
System.out.println("符合要求的整数有"+count+"个");
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HQnFilak-1600214604356)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200912111028113.png)]
继承
继承主要解决的问题就是:共性抽取
当子类、父类、局部变量都是相同的名称时
局部变量 | 直接写 |
---|---|
本类的成员变量 | this.成员变量名称 |
父类的成员变量 | super.成员变量名称 |
继承中成员方法的访问特点
在父子类中,父子类方法重名时,方法的调用原则
规则:创建的对象是谁就优先调用谁的方法,没有就往上找,就近原则
在继承关系中,方法的名称一样,参数列表也一样
重写/覆盖/覆写 | 在继承关系中,方法名称和参数一样 |
---|---|
重载 | 方法的名称一样,方法的参数列表不一样 |
注意事项:方法的重写
- 子类方法的返回值范围一定要小于父类的返回值范围
- 子类方法的权限必须大于父类方法的权限修饰符public>projected>(default)>private
备注:default不是关键字,是省略不写