JAVA基础DAY02

JAVA基础DAY02

1. for 循环结构

1.1 for的基本用法

for(语句体1;语句体2;语句体4){
语句体3;
}

1.2 break和continue

break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环

1.3 嵌套循环

1)循环中套循环,一般多行多列时使用,外层控制行,内层控制列
2)执行规则: 外层循环走一次,内层循环走所有次
3)建议:嵌套层数越少越好,能用一层就不用两层,能用两层就不用三层
若业务必须通过三层以上的循环来解决,说明设计有问题
4)break只能跳出当前一层循环

public class ForDemo {
public static void main(String[] args) {
//输出9的乘法表,只要不能被3整除的数
for(int num=1;num<=9;num++) {
if(num%3!=0) {
System.out.println(num+"9="+num9);
}
}
//输出9的乘法表,跳过能被3整除的数
for(int num=1;num<=9;num++) {
if(num%3==0) {
continue; //跳过循环体中剩余语句而进入下一次循环
}
System.out.println(num+"9="+num9);
}
/*
* num=1 1* 9=9
* num=2 2* 9=18
* num=3
* num=4 4* 9=36
* num=5 5* 9=45
* num=6
* num=7 7* 9=63
* num=8 8* 9=72
* num=9
* num=10 false
*/

//九九乘法表
public class MultiTable {
public static void main(String[] args) {
for(int num=1;num<=9;num++) { //控制行
for(int i=1;i<=num;i++) { //控制列
System.out.print(i+""+num+"="+inum+"\t");
}
System.out.println(); //换行
}
/*
* num=3
* i=1 13=3
* i=2 2
3=6
* i=3 33=9
* i=4
* 换行
* num=2
* i=1 1
2=2
* i=2 22=4
* i=3
* 换行
* num=1
* i=1 1
1=1
* i=2
* 换行
*/

}

}

2. 数组

2.1 数组的定义

1)是一种数据类型(引用类型)
2)相同数据类型元素的集合
3)数组的定义:
int[] arr = new int[10]; //声明整型数组arr,包含10个元素,每个元素都是int类型,默认值为0

2.2 数组的初始化

数组的初始化: 初始化的是数组中的元素
int[] arr = new int[3]; //0,0,0
int[] arr = {2,5,8}; //2,5,8
int[] arr = new int[]{2,5,8}; //2,5,8
int[] arr;
arr = {2,5,8}; //编译错误,此方式只能声明同时初始化
arr = new int[]{2,5,8}; //正确

2.3 数组的访问

数组的访问: 访问的是数组中的元素
5.1)通过(数组名.length)可以获取数组的长度(元素的个数)
int[] arr = new int[3];
System.out.println(arr.length); //3
5.2)通过下标/索引来访问数组中的元素
下标从0开始,最大到(数组的长度-1)
int[] arr = new int[3];
arr[0] = 100; //给arr中第1个元素赋值为100
arr[1] = 200; //给arr中第2个元素赋值为200
arr[2] = 300; //给arr中第3个元素赋值为300
//arr[3] = 400; //运行时----发生数组下标越界异常
System.out.println(arr[arr.length-1]); //输出最后一个元素的值

2.4 数组的遍历

数组的遍历: 从头到尾挨个走一遍
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99之间的随机数
System.out.println(arr[i]); //输出每个元素的值
}

int[] arr = new int[10];
for(int i=0;i<10;i++){
arr[i]------代表arr中的每一个元素
}

int[] arr = new int[10];
for(int i=0;i<10;i++){ //遍历arr数组
arr[i] = 100; //给每个元素都赋值为100
System.out.println(arr[i]); //输出每个元素的值
}

arr[0] = 100;
arr[1] = 100;
arr[2] = 100;
arr[3] = 100;
arr[4] = 100;
arr[5] = 100;
arr[6] = 100;
arr[7] = 100;
arr[8] = 100;
arr[9] = 100;

int[] arr = new int[3]; //0,0,0

arr[0]------------代表arr中的第1个元素(int)
arr[1]------------代表arr中的第2个元素(int)
arr[2]------------代表arr中的第3个元素(int)

int和int[]是两种完全不同的数据类型
int a; //声明整型变量a
int[] a; //声明整型数组变量a
double[] d; //声明浮点型数组变量d
boolean[] b; //声明布尔型数组变量b

2.5 数组的排序

//数组的演示
public class ArrayDemo {
public static void main(String[] args) {

	//8)数组的排序:
	int[] arr = {23,67,4,18,94,2};
	
	Arrays.sort(arr); //对arr升序排列
	
	System.out.println("升序输出:");
	for(int i=0;i<arr.length;i++) {
		System.out.println(arr[i]);
	}
	
	System.out.println("降序输出:");
	for(int i=arr.length-1;i>=0;i--) {
		System.out.println(arr[i]);
	}
	
	
	
	
	
	
	
	
	
	
	
	
	/*
	//7)数组的复制:
	int[] a = {10,20,30,40,50};
	//数组的扩容(创建了一个更大的新的数组,并将数据复制进去了)
	a = Arrays.copyOf(a, a.length-1);
	for(int i=0;i<a.length;i++) {
		System.out.println(a[i]);
	}
	*/
	/*
	//a:源数组
	//b:目标数组
	//6:目标数组的长度(元素个数)
	//  ----若目标数组长度>源数组长度,则末尾补默认值
	//  ----若目标数组长度<源数组长度,则末尾截取
	int[] b = Arrays.copyOf(a,4); //从头到头,整个复制
	for(int i=0;i<b.length;i++) {
		System.out.println(b[i]);
	}
	*/
	
	
	/*
	int[] a = {10,20,30,40,50};
	int[] b = new int[6]; //0,0,0,0,0,0
	//a:源数组
	//1:源数组的起始下标
	//b:目标数组
	//0:目标数组的起始下标
	//4:要复制的元素个数
	System.arraycopy(a,1,b,0,4); //灵活性好
	for(int i=0;i<b.length;i++) {
		System.out.println(b[i]);
	}
	*/
}

}

3. 面向对象

3.1 什么是类?什么是对象?

1)现实生活中是由很多很多的对象组成的,基于对象抽出了类
2)对象:软件中真实存在的单个东西/个体
类:类型/类别,代表一类个体
3)类是对象的模板/模子,对象是类的具体的实例
4)类中可以包含:
4.1)对象所共有的属性/特征--------------成员变量
4.2)对象所共有的行为/动作--------------方法
5)一个类可以创建多个对象

3.2 如何创建类?如何创建对象?如何访问成员?

1)创建类: class
2)创建对象: new
3)访问成员: .

/学生类
public class Student {
//成员变量
String name;
int age;
String address;

//方法
void study() {
	System.out.println(name+"在学习...");
}
void sayHi() {
	System.out.println("大家好,我叫"+name+",今年"+age+"岁了,家住"+address);
}

}

//学生类的测试类
public class StudentTest {
public static void main(String[] args) {
//创建一个学生对象
Student zs = new Student();
//给成员变量赋值
zs.name = “zhangsan”;
zs.age = 25;
zs.address = “河北廊坊”;
//调用方法
zs.study();
zs.sayHi();

	Student ls = new Student();
	ls.name = "lisi";
	ls.age = 24;
	ls.address = "黑龙江佳木斯";
	ls.study();
	ls.sayHi();
	
	//1)创建了一个学生对象
	//2)给所有成员变量赋默认值
	Student ww = new Student();
	ww.study();
	ww.sayHi();
	
}

}

3.3 方法的相关应用

1.方法的签名:方法名+参数列表

2.方法的重载(overload):------------简化用户的调用
1)发生在同一类中,方法名相同,参数列表不同,方法体不同
2)编译器在编译时会根据方法的签名来自动绑定调用的方法

//重载的演示
public class OverloadDemo {
public static void main(String[] args) {
Aoo o = new Aoo();
o.show();
o.show(“zhangsan”);
o.show(25);
o.show(“zhangsan”, 25);
o.show(25, “zhangsan”);
}
}
class Aoo{
void show() {}
void show(String name) {}
void show(int age) {}
void show(String name,int age) {}
void show(int age,String name) {}
//int show() { return 1; } //编译错误,重载与返回值类型无关
//void show(String address) {} //编译错误,重载与参数名称无关
}

3.构造方法:构造函数、构造器、构建器------------复用给成员变量赋值的代码
1)给成员变量赋初值
2)与类同名,没有返回值类型(连void都没有)
3)在创建(new)对象时被自动调用
4)若自己不写构造方法,则编译器默认提供一个无参构造方法,
若自己写了构造方法,则不再默认提供
5)构造方法可以重载

//学生类
public class Student {
String name;
int age;
String address;

Student(String name,int age,String address){
	this.name = name;
	this.age = age;
	this.address = address;
}

void study() {
	System.out.println(name+"在学习...");
}
void sayHi() {
	System.out.println("大家好,我叫"+name+",今年"+age+"岁了,家住"+address);
}

}

//构造方法的演示
public class ConsDemo {
public static void main(String[] args) {
//Student zs = new Student(); //编译错误

	Student zs = new Student("zhangsan",25,"LF");
	Student ls = new Student("lisi",26,"JMS");
	zs.sayHi();
	ls.sayHi();
}

}

4.this:指代当前对象,哪个对象调用方法它指的就是哪个对象
只能用在方法中,方法中访问成员变量之前默认有个this.
this的用法:
1)this.成员变量名--------访问成员变量
--------当成员变量与局部变量同名时,访问成员变量时this不能省略
2)this.方法名()----------调用方法(一般不用)
3)this()-----------------调用构造方法(一般很少用)

5.null:表示空,没有指向任何对象
若引用的值为null,则该引用不能再进行任何点操作了,
若操作则发生NullPointerException空指针异常

在这里插入图片描述
在这里插入图片描述

4. 继承的应用

4.1 引用类型数组

1)Student[] stus = new Student[3];
stus[0] = new Student(“zhangsan”,25,“LF”);
stus[1] = new Student(“lisi”,26,“JMS”);
stus[2] = new Student(“wangwu”,27,“SD”);
System.out.println(stus[0].name); //输出第1个学生的名字
stus[1].age = 24; //给第2个学生的年龄修改为24
stus[2].sayHi(); //第3个学生跟大家问好
for(int i=0;i<stus.length;i++){ //遍历所有学生
System.out.println(stus[i].name); //输出每个学生的名字
stus[i].sayHi(); //每个学生跟大家问好
}
2)Student[] stus = new Student[]{
new Student(“zhangsan”,25,“LF”),
new Student(“lisi”,26,“JMS”),
new Student(“wangwu”,27,“SD”)
};

4.2 继承

继承:
1)作用:代码复用
2)通过extends来实现继承
3)超类/父类:派生类所共有的属性和的行为
派生类/子类:派生类所特有的属性和行为
4)派生类继承超类后,派生类具有:派生类的+超类的
5)一个超类可以有多个派生类
一个派生类只能继承一个超类------单一继承
6)继承具有传递性
7)java规定:构造派生类之前必须先构造超类
—在派生类的构造中若自己没有调用超类构造,则默认super()调用超类的无参构造
—在派生类的构造中若自己调用了超类构造,则不再默认提供
注意:super()调用超类构造方法,必须位于派生类构造方法的第一行

2.super:指代当前对象的超类对象
super的用法:
1)super.成员变量名-------------访问超类的成员变量
2)super.方法名()--------------调用超类的方法--------明天下午方法重写时讲
3)super()--------------------调用超类的构造方法

//super的演示
public class SuperDemo {
public static void main(String[] args) {
Boo o = new Boo();
}
}

class Coo{
Coo(int a){
}
}
class Doo extends Coo{
Doo(){
super(25);
}

/*
//如下代码为默认的
Doo(){
	super();
}
*/

}
class Aoo{
Aoo(){
System.out.println(“超类构造”);
}
}
class Boo extends Aoo{
Boo(){
super(); //默认super()来调用超类的无参构造—必须位于第一行
System.out.println(“派生类构造”);
}
}

练习:---------------如下代码写在新建包中

1.创建Person类,包含:
1)成员变量:name,age,address
2)构造方法:Person(3个参数){ 赋值 }
3)方法:sayHi(){ 输出3个数据 }
2.创建学生类Student,继承Person,包含:
1)成员变量:学号stuId(String)
2)构造方法:Student(4个参数){ super调超类3参构造、赋值stuId }
3.创建老师类Teacher,继承Person,包含:
1)成员变量:工资salary(double)
2)构造方法:Teacher(4个参数){ super调超类3参构造、赋值salary }
4.创建医生类Doctor,继承Pering)
1)成员变量:职称level(数)
2)构造方法:Doctor(4个参数){ super调超类3参构造、赋值level }
5.创建测试类Test,main中:
1)创建学生数组stus,包含3个元素,给元素赋值,遍历输出名字并问好
2)创建老师数组tes,包含3个元素,给元素赋值,遍历输出名字并问好
3)创建医生数组docs,包含2个元素,给元素赋值,遍历输出名字并问好

答案

//练习

public class Test {
public static void main(String[] args) {
Student[] stus = new Student[3];
stus[0] = new Student(“aaa”,25,“LF”,“111”);
stus[1] = new Student(“bbb”,24,“JMS”,“222”);
stus[2] = new Student(“ccc”,26,“SD”,“333”);
for(int i=0;i<stus.length;i++) {
System.out.println(stus[i].name);
stus[i].sayHi();
}

	Teacher[] tes = new Teacher[3];
	tes[0] = new Teacher("ddd",35,"LF",5000);
	tes[1] = new Teacher("eee",44,"LF",8000);
	tes[2] = new Teacher("fff",56,"SD",10000);
	for(int i=0;i<tes.length;i++) {
		System.out.println(tes[i].name);
		tes[i].sayHi();
	}
	
	Doctor[] docs = new Doctor[2];
	docs[0] = new Doctor("ggg",25,"LF","主治医师");
	docs[1] = new Doctor("hhh",34,"JMS","副主任医师");
	for(int i=0;i<docs.length;i++) {
		System.out.println(docs[i].name);
		docs[i].sayHi();
	}
}

}

class Person{
String name;
int age;
String address;
Person(String name,int age,String address){
this.name = name;
this.age = age;
this.address = address;
}
void sayHi() {
System.out.println(“大家好,我叫”+name+",今年"+age+“岁了,家住”+address);
}
}

class Student extends Person{
String stuId; //学号
Student(String name,int age,String address,String stuId){
super(name,age,address);
this.stuId = stuId;
}
}
class Teacher extends Person{
double salary; //工资
Teacher(String name,int age,String address,double salary){
super(name,age,address);
this.salary = salary;
}
}
class Doctor extends Person{
String level; //职称
Doctor(String name,int age,String address,String level){
super(name,age,address);
this.level = level;
}
}

5. 向上造型

1.向上造型:
1)超类型的引用指向派生类的对象
2)能点出来什么,看引用的类型--------这是规定,记住就行了

//向上造型的演示
public class UploadDemo {
public static void main(String[] args) {
Aoo o1 = new Aoo();
o1.a = 1;
o1.show();
//o1.b = 2; //编译错误,超类不能访问派生类的
//o1.test(); //编译错误,…

	Boo o2 = new Boo();
	o2.b = 1;
	o2.test();
	o2.a = 2;   //正确,派生类可以访问超类的
	o2.show();
	
	Aoo o3 = new Boo(); //向上造型
	o3.a = 1;
	o3.show();
	//o3.b = 2; //编译错误,能点出来什么,看引用的类型
	//o3.test();  //编译错误,......
}

}
class Aoo{
int a;
void show() { }
}
class Boo extends Aoo{
int b;
void test() { }
}

5.1 方法的重写(override):重新写、覆盖

方法的重写(override):重新写、覆盖
1)发生在父子类中,方法名相同,参数列表相同,方法体不同
2)重写方法被调用时,看对象的类型---------这是规定,记住就行了
3)重写需遵循"两同两小一大"原则:-----------了解,一般都是一模一样的
3.1)两同:
3.1.1)方法名相同
3.1.2)参数列表相同
3.2)两小:
3.2.1)派生类方法的返回值类型小于或等于超类方法的
1)void时,必须相等
2)基本类型时,必须相等
3)引用类型时,小于或等于
3.2.2)派生类方法抛出的异常小于或等于超类方法的
3.3)一大:
3.3.1)派生类方法的访问权限大于或等于超类方法的
//重写的演示
public class OverrideDemo {
public static void main(String[] args) {

}

}

//超类大,派生类小
class Coo{ //超类
void show() {}
double test() { return 0.0; }
Doo say() { return null; }
Coo sayHi() { return null; }
}
class Doo extends Coo{ //派生类
//int show() { return 1;} //编译错误,void时必须相同
//int test() { return 0; } //编译错误,基本类型时必须相同
//Coo say() { return null; } //编译错误,引用类型时必须小于或等于
Doo sayHi() { return null; } //正确
}

3.重写与重载的区别:------------常见面试题(答的时候只答1.1和2.1即可)
1)重写(override/overriding):
1.1)发生在父子类中,方法名相同,参数列表相同,方法体不同
1.2)遵循"运行期绑定",看对象类型来调用方法
2)重载(overload/overloading):
2.1)发生在同一类中,方法名相同,参数列表不同,方法体不同
2.2)遵循"编译期绑定",看参数/引用类型来绑定调用方法

//重写与重载的区别
public class OverloadOverrideDemo {
public static void main(String[] args) {
Eoo eoo = new Eoo();
Father o = new Son();
eoo.show(o); //重载时,看参数/引用类型来绑定方法
}
}

class Eoo{
void show(Father o) {
System.out.println(“超类型参数”);
}
void show(Son o) {
System.out.println(“派生类型参数”);
}
}

class Father{ //超类
}
class Son extends Father{ //派生类

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值