day01-面向对象【阶段一知识回顾、继承】

————-第三天 流程控制语句—————–

流程控制语句的分类:
顺序结构;
选择结构:

    1.if语句

        1.1 第一种语句格式:

            if(关系表达式){
                语句体;
            }

            其它的代码;

            执行流程:
                1.先判断 关系表达式 的值是true还是false;
                2.如果为true就执行语句体,否则就不执行语句体;

        1.2 第二种语句格式:
            if(关系表达式){
                语句体1;
            }else{
                语句体2;
            }
            执行流程:
                1.先判断 关系表达式 的值是true还是false;
                2.如果为true就执行语句体1,否则就执行语句体2;

        1.3 第三种语句格式:

            if(关系表达式1){
                语句体1;
            }else if(关系表达式2){
                语句体2;
            }
            ...
            else{
                语句体n;
            }
            执行流程:
                1.先判断 关系表达式1 的值是true还是false;
                2.如果为true就执行语句体1,否则就判断 关系表达式2的值,看其结果是true还是false;
                3.如果是true是就执行语句体2,否则就继续判断下一个关系表达式,看其结果是true还是false;
                4.如果以上所有关系表达式的值都为false,就执行语句体n;

    2.switch语句

        格式:
            switch(表达式){

                case 目标值1:
                    语句体1;
                    break;
                case 目标值2:
                    语句体2;
                    break;  
                ...

                default:
                    语句体n+1;
                    break;  

            }

            执行流程:
                1.先计算表达式的值;
                2.然后使用表达式的值,先与第一个case语句中的目标值进行比较;
                3.如果相等,就执行语句体1;如果不相等就与第二个case语句中的目标值进行比较;
                4.如果与与第二个case语句中的目标值相等,就执行语句体2;如果不相等就下一个case语句中的目标值进行比较;
                5.如果表达式的值与上面所有的目标值都不想等,就执行default语句中的语句体n+1;
                6.在以上步骤中,如果执行了break语句,就会结束整个switch语句;                           

循环结构:
    1.for循环语句
        格式:

            for(初始化语句①;条件判断语句②;控制条件语句④){
                循环体语句③;
            }

            ...
            其它的代码;

            初始化语句:定义循环变量,然后初始化;
            条件判断语句:判断循环变量是否满足某个条件;
            循环体语句:重复执行的代码;
            控制条件语句:修改循环变量,通过修改循环变量来控制是否满足某个条件的;

        执行流程:
            ①②③④ -> ②③④ -> ②③④...,当②的结果为false就结束整个for循环语句;

    2.while循环语句
        格式1:

            初始化语句①;
            while(条件判断语句②){
                循环体语句③;
                控制条件语句④;
            }

            执行流程:
                ①②③④->②③④->②③④...,当②的结果为false就结束整个while循环语句;

        格式2:

            while(条件判断语句②){
                循环体语句③;
            }


    3.do...while循环语句

        格式1:

            do{
                循环体语句③;
            }while(条件判断语句②);


        格式2:

            初始化语句①;
            do{
                循环体语句③;
                控制条件语句④;
            }while(条件判断语句②);

         执行流程:
            ①③④->②③④->②③④...,当②的结果为false就结束整个do...while循环语句;


    三种循环语句的区别:
        1.do...while循环,一上来就先执行循环体,而for循环和while循环语句只有在满足循环条件的情况下才执行循环体语句;


    4.跳转控制语句:
        1.break 中断,结束的意思
            应用场景:
                1.switch语句中;
                2.循环语句中:
                    for(初始化语句①;条件判断语句②;控制条件语句④){
                        循环体语句③;
                        break;
                    }
        2.continue 继续的意思

              跳过本次循环,继续 下一次循环;
            应用场景:

                1.循环语句中:

                    1<=i<=10

                    for(初始化语句①;条件判断语句②;控制条件语句④){
                        if(i>3){
                            continue;
                        }

                        循环体语句③;
                    }

————第四天 数组——————

1.定义格式

数据类型[] 数组名 = new 数据类型[长度];
数据类型[] 数组名 = {元素值1,元素值2,...};

2.给元素赋值

int[] iArray = new int[3];
for(int i=0;i<iArray.length;i++){
    iArray[i] = (i+1)*5;
}

iArray[0] = 5;
iArray[1] = 10;
iArray[2] = 15;

————第五天 方法—————————-

1.方法

for(int i=1;i<=5;i++){
System.out.println(“helloworld”)
}

格式:

修饰符 返回值类型 方法名(参数列表){
    方法体;
    return 返回值;
}

———–第七天 面向对象—————————-

1.类的作用:
类是用来描述现实世界中的某一类事物的;

2.怎么描述:

属性:
    姓名;
    年龄;
行为:
    吃饭;
    学习;
    睡觉;

在java中类写属性和行为;

3.怎么写属性和行为:
1.通过成员变量表示属性;
2.通过成员方法表示行为;

4.对象

对象是这一类事物中的一个个体;


通过对象访问成员变量和成员方法:
    1.创建对象:
        类名 对象名 = new 构造方法(参数列表);

    2.访问变量和方法:
        对象名.变量名;
        对象名.方法名;

5.封装

封装:把类中不需要对外提供的变量或者方法隐藏起来;
使用private关键字修饰变量或者方法;
给被private修饰的变量提供get/set方法;

6.this关键字
表示当前类的对象;
哪个对象正在调用this所在的方法,this就表示哪个对象;

7.匿名对象

Person p1 = new Person();
// 匿名对象
new Person();

Student s = new Student();

new Student().getAge();


new Student().setAge(20);


匿名对象可以作为对象来调用它的成员;

匿名对象只能被使用一次;

用途;
    匿名对象可以作为方法的参数,也可以作为方法的返回值;

第一天

1.类与类之间的关系

1.组合
    在A类中用到了B类, A类与B类之间的关系就是组合关系;

    public class B{
        ...
    }

    public class A{
        int age;
        B b;
        ....
    }

    public class XinZang{
        ...

    }

    public class Person{
        String name;
        int age;
        //XinZang xz;

        public void setXinZang(XinZang xz){
            ...
        }
        ...
    }


2.继承


    在java中继承指的是子类继承父类,子类就拥有了父类中所有的非私有成员;
    格式:

        修饰符 class 子类名 extends 父类名{
            定义子类特有的成员;
        }

        public class Fu{
            int a = 100;
            private int b = 200;

            public void method01(){
                sysout("-----------method01----");
            }
        }

        // zi类继承Fu类
        public class Zi extends Fu{

        }



3.代理

2.继承的特点

1.在java中只有单继承:一个子类只能一个父类;
2.可以多层继承:B继承A,C继承B;

3.继承的好处:
1.提高代码的重复使用率;
2.可以在子类中扩展自己的功能;

4.使用类名作为方法的参数类型

在调用方法时必须给方法传递这个类的对象
public static void setPerson(Person p){
    p.setAge(20);
    p.setName("冬冬");
}

5.使用类名作为方法的返回值类型
要求给方法返回数据时,必须返回这个类的对象;

public static Person getPerson(){
    Person p = new Person();
    return p;
}