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 23=6
* i=3 33=9
* i=4
* 换行
* num=2
* i=1 12=2
* i=2 22=4
* i=3
* 换行
* num=1
* i=1 11=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{ //派生类