JAVASE第7天笔记

最新推荐文章于 2024-11-01 23:06:29 发布

深圳_JAVALIke

最新推荐文章于 2024-11-01 23:06:29 发布

阅读量273

点赞数

本文链接：https://blog.csdn.net/baidu_36439112/article/details/53652253

版权

Day07课堂笔记

标签（空格分隔）： java基础

关于面向对象和面向过程的一些区别

面向过程版本

class FaceObjectDemo {
    /*
    1、1、请分别使用使用面向对象思想和面向过程思想去描述以下把大象装进冰箱案例
            a)  打开冰箱
            b)  装进大象
            c)  关闭冰箱
    */
    public static void main(String[] args) {
        //面向过程版本
        //如果以后可能要经常调用这段代码,这个时候,我们会考虑把这些功能封装到函数(方法)以方便重复调用
        //开始调用函数
        /*
            open();
            in();
            close();
        */
    }

    public static void open(){
        System.out.println("打开冰箱");
    }

    public static void close(){
        System.out.println("关闭冰箱");
    }

    public static void in(){
        System.out.println("装进大象");
    }


}

面向对象版本

class FaceObjectDemo2 {
    /*
    1、请分别使用使用面向对象思想和面向过程思想去描述以下把大象装进冰箱案例
            a)  打开冰箱
            b)  装进大象
            c)  关闭冰箱

            分析: 名词提炼法 冰箱 大象
    */
    public static void main(String[] args) {
        //第一步:创建冰箱对象,调用对象的打开方法
        bingXiang bx = new bingXiang();
        bx.open();
        //第二步:创建大象对象,调用装进冰箱的方法
        daXiang dx = new daXiang();
        dx.in();
        //第三步:关闭冰箱
        bx.close();

    }
}

class bingXiang
{
    public void open(){
        System.out.println("打开冰箱");
    }
    public void close(){
        System.out.println("关闭冰箱");
    }
}

class daXiang
{
    public void in(){
        System.out.println("装进冰箱");
    }
}

构造方法(非常非常非常重要)

构造方法的作用及格式特点分别是什么？
作用: 给成员变量进行数据初始化
格式: 跟类名相同
特点:
没有返回值,可以有return(但是不推荐写,以后开发都不写)
举例:
最简单版本

class Student{
    //这是构造方法
    public Student(){
    }
}

有成员变量版本

class Student{
    String name;
    int age;
    int classRoomNum;
    //给成员变量进行数据初始化
    public Student(){
        classRoomNum = 1309;
    }
}

思考:构造方法是否可以重载?
什么是重载:方法名相同,参数列表不同(数据类型数量顺序)
使用构造方法的时候，注意事项有哪些？
(1)如果我们没有给出构造方法,系统会默认给我们添加一个
(2)如果我们自己给出了构造方法(无参/有参),系统就不再自动提供
(3)在使用的时候,如果我们书写了有参构造,这个时候建议自己手动写出无参构造,开发中都要书写
补充:可以使用Xjad这种反编译软件去看看看

class Student{
    String name;
    int age;
    public Student(){
        System.out.println("这是空参");
    }

    public Studnet(String name,int age){
        this.name = name;
        this.age = age;
    }

}

构造方法什么时候调用的?(非常非常重要)
创建对象的时候 类名对象名 = new 类名()
调用有参构造 类名对象名 = new 类名(实际参数)
Student s = new Student(); //调用无参的
s.setName(“张三”); //调用方法赋值
s.setAge(18);
Student s = new Student(“张三”,18); //调用有参构造赋值

关于调用构造方法赋值和成员方法赋值的区别?

构造方法赋值:创建对象的时候调用,也就意味着这个方法只会调用一次,也就是说构造方法赋值的方式只能创建对象的时候初始化一次.
set方法赋值: 怎么调用?通过对象名来调用,这个时候,只要我们创建出对象之后,我们就可以随时使用这个对象,也就意味着这个方法可以调用多次.
在开发中,都使用Set这方式赋值比较多,通常都是set方法
PS:如果要使用set方法赋值,通常都是创建对象时候使用无参构造

超级小白版学生类书写(非常非常非常重要)

//第七步:书写测试类,测试类的前提必须要有main方法
class Demo4_Student {
    //第八步:书写一个main方法
    public static void main(String[] args) {
        //第九步:开始创建对象,调用无参构造创建对象
        Student s1 = new Student();                 //使用空参构造
        //第十步:调用对象的set方法给成员变量赋值
        s1.setName("张三");                           //设置姓名
        s1.setAge(23);                              //设置年龄
        //第十一步:输出你赋值后的这些姓名年龄信息,调用的是get方法,get方法专门用于获取设置后的成员变量信息
        System.out.println("我的姓名是:" + s1.getName() + ",我的年龄是:" + s1.getAge());
        //getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作

        //第十二步:创建一个对象,调用有参构造方法,给这个有参构造传入实际的数据
        Student s2 = new Student("李四",24);
        //第十三步:调用对象的show方法,这个show方法使用来输出用户的信息的.也就是你构造函数赋的值或者是你set方法赋的值都可以
        s2.show();                                  //只是为了显示属性值
    }
}
/*
* A:案例演示
    * 学生类：
        * 成员变量：
            * name，age
        * 构造方法：
            * 无参，带两个参
        * 成员方法：
            * getXxx()/setXxx()
            * show()：输出该类的所有成员变量值
* B:给成员变量赋值：
    * a:setXxx()方法
    * b:构造方法

* C:输出成员变量值的方式：
    * a:通过getXxx()分别获取然后拼接
    * b:通过调用show()方法搞定
*/
//第一步:书写一个类 类名叫Student
class Student {
    //第二步:开始书写成员变量
    private String name;                            //姓名
    private int age;                                //年龄
    //第三步:书写空参构造方法,没有参数的构造方法就叫空参
    public Student(){}                              //空参构造
    //第四步:书写有参构造方法,有参数的
    public Student(String name,int age) {           //有参构造
        //赋值
        this.name = name;
        this.age = age;
    }
    //第五步:开始书写对应成员变量的set/get方法
    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;
    }
    //第六步:书写一个普通的成员方法,这个成员方法的功能就是打印输出这个对象的成员变量信息,也就是你赋值的那些信息
    public void show() {
        System.out.println("我的姓名是:" + name +  ",我的年龄是:" +  age);
    }
}

对象的加载流程

class Demo1_Student {
    public static void main(String[] args) {
        Student s = new Student();
        s.show();
    }
}

class Student {
    private String name = "张三";
    private int age = 23;

    public Student() {
        name = "李四";
        age = 24;
    }

    public void show() {
        System.out.println(name + "..." + age);
    }
}

对象加载步骤超级小白版(理解)

第一步 :加载Demo1_Student.class加载到方法区
第二步: 主方法进栈main方法进栈
第三步: 去方法区判断是否存在Student.class,如果没有,就加载这Student.class文件进入方法区,如果有,就不加载
第四步: Student s 在main方法里面,也就是在栈内存,紧接着new Student()会去堆内存开辟空间
第五步:加载类信息,也就是类里面的成员变量信息全部加载到堆内存这个对象的区域
第六步:默认初始化完之后,开始显式初始化`private String name = "张三";`
第七步:构造方法进栈,给成员变量开始赋值,`  name = "李四";`会把之前的数据给更改掉
第八步:构造方法弹栈
第九步:把堆内存中的对象地址给S变量,也就是s保存了这个对象的地址值

静态static关键字(理解)

static 可以修饰什么?
修饰成员变量,被static修饰之后的成员变量有什么特点?被所有对象共享一份.
整个教室 : 老师教室空调音响
用static修饰后的成员变量有什么好处?
节省内存空间!所有的对象都是共享一份数据!

class Static_Demo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.name = "小张";
        s1.age = 18;
        s1.teacher = "超帅";
        s1.show();

        Student s2 = new Student();
        s2.name = "小陈";
        s2.age = 28;
        s2.teacher = "超帅";
        s2.show();

        Student s3 = new Student();
        s3.name = "小林";
        s3.age = 38;
        s3.teacher = "超帅";
        s2.show();

    }
}

class Student
{
    String name;   //null
    int age;       //0
    static String teacher; 

    public Student(){

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

    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;
    }

    public void setTeacher(String teacher){
        this.teacher = teacher;
    }

    public String getTeacher(){
        return teacher;
    }

    //方法 : 功能
    public void show(){
        System.out.println("姓名:" + name + ",年龄:" + age + ",老师:" + teacher);
    }

}

静态修饰成员有什么特点?(知道)

特点
1,随着类的加载而加载,优先于对象存在(因为进入的是方法,类也是在方法区的)
2,所有的对象都共享同一份
3,被静态修饰的成员可以通过类名调用,强调!重要

静态修饰的成员注意事项?

1,静态方法里面不能使用this关键字,为什么?因为静态成员是随着类的加载而加载,对象是需要创建才有,不创建没有对象,而this关键字指向的是当前对象.所以在静态加载的时候,还没有对象,所以不能使用关键字this;
2,静态方法里面不能访问非静态的的成员变量或者非静态的成员方法
3,非静态的成员方法可以调用静态的成员方法或者非静态的成员方法.

静态修饰的方法是有 static关键字的
举例 ‘public static void teach(){};’这是静态的成员方法
非静态修饰的方法没有 static关键字
举例 public void run(){} 这是非静态的成员方法

思考题：静态变量和成员变量有哪些区别？(理解)

区别	静态变量	成员变量
所属	属于类	对象
内存位置	方法区下的静态区	堆内存区域
生命周期	随类加载而加载,随类消失而消失	随着对象的加载而存在,随对象消失而消失
调用上	类名/对象名	必须通过对象名才能调用

局部变量和成员变量的区别是什么？(理解)

区别	局部变量	成员变量
类中位置	方法声明上/方法体内	类中方法外
内存位置	栈内存	堆内存
生命周期	随方法的调用而存在,随方法的弹栈而消失	随对象创建存在,随对象消失而消失
默认初始化值	没有默认值	有
调用方式	直接在方法里面可以调用	需要用对象名来调用,如果被static修饰了,就可以用类名

main方法的解释

class Demo3_Main {
    public static void main(String[] args) {            
        /*
        public : 被jvm调用,所以权限要足够大
        static : 被jvm调用,不需要创建对象,直接类名.调用即可
        void   : 被jvm调用,不需要有任何的返回值
        main   : 只有这样写才能被jvm识别,main不是关键字
        String[] args : 以前是用来接收键盘录入的
        */

        System.out.println(args.length);
        for (int i = 0;i < args.length ;i++ ) {
            System.out.println(args[i]);
        }
    }
}

工具类的应用

为什么要写工具类?不写可以不可以?
通常我们会将一些常用的功能写到一个类里面,这种类通常称为工具类;
举例: 在就业班学到的JDBC连接数据库,这个时候需要书写工具类,另外还有其他的工具类:例如字符串操作等等工具类 StringUtils工具类 ,时间日期工具类等等
在写工具类的时候,通常我们都会把工具类里面的方法变成静态的,以方便使用类名调用.
如果一个工具类里面的所有方法都是静态的,那么我们需要再做一步,把这个类的构造方法私有,避免用户再次创建对象来调用.我们通常书写工具类的时候,就是为了方便调用,这个时候我们就需要把这些方法写成静态的的,这样就可以使用类名.方法名()来调用!

Math 类里面的一个随机数功能(练习)

如何获取一个1-33之间的随机数？
Math.random(): 生成的是一个0.0000~0.999999这种小数
(int)(Math.random()*33)+1;

class Random_Demo {
    public static void main(String[] args) {
        for (int i = 1;i <=10 ;i++ )
        {
            System.out.println((int)(Math.random()*33) + 1);
        }

    }
}

猜数字小游戏(练习)

/*
* A:案例演示
    * 需求：猜数字小游戏(数据在1-100之间)
*/
import java.util.Scanner;
class Test1_GuessNum {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);                //创建键盘录入对象
        System.out.println("请输入一个整数,范围在1-100之间");
        int guessNum = (int)(Math.random() * 100) + 1;      //心里想的随机数
        while (true) {                                      //因为需要猜很多次,所以用无限循环
            int result = sc.nextInt();                      //大家猜的数
            if (result > guessNum) {                        //如果你们猜的数大于了我心里想的数
                System.out.println("大了");                   //提示大了
            } else if (result < guessNum) {                 //如果你们猜的数小于了我心里想的数
                System.out.println("小了");                   //提示小了
            } else {                                        //如果既不大也不小
                System.out.println("中了");                   //中了
                break;
            }

        }
    }
}