Day08

作者: 拼搏男孩 | 来源:发表于2019-11-28 17:37 被阅读0次

    一. 构造方法

    1. 定义

      • 用于初始化对象
      • 我们在通过new关键字创建对象的时候,必须调用构造方法
    2. 特点

      • 方法名与类名相同(大小写也要于类名相同)
      • 没有返回值类型, 注意, 连void都没有
      • 没有具体的返回值return
      • 构造方法可以是有参的,也可以是无参的
    3. 演示

      public class Student {
       //构造方法
       public Student(){
           System.out.println("构造方法运行了");
       }
      }
      
    4. 注意事项

      • 如果没有写构造方法, 那么编译器会自动加一个空参的构造方法
      • 如果已经写了有参的构造方法, 编译器就不会再加上空参的构造了
      • 这时,如果还想使用空参的构造, 那么,就需要手动补上空参构造
      • 构造方法必须通过new关键字来调用, 不可以使用对象名来调用
      • 构造方法也是成员方法, 只是比较特殊而已, 所有成员方法的属性构造方法也拥有
      • 创建对象的时候, 只能调用一个构造方法,但构造方法内部可以相互调用
      • 本类中的成员方法无法直接调用构造方法
    5. 演示

      public class Student {
       
       //已经有了有参的构造,编译器就不会在自动添加空参的构造了
       public Student(String name){
           System.out.println("构造方法运行了");
       }
       
      }
      
    6. 带参数的初始化

      • 初始化对象的时候, 我们可以直接通过构造方法对成员变量进行赋值

        public class Student {
           
           private String name ;
           
           //通过构造方法对成员变量进行赋值
           public Student(String name){
               this.name = name;
           }
           
           public String getName() {
               return name;
           }
           public void setName(String name) {
               this.name = name;
           }
        }
        
    7. 测试题

      • 新生入学,需要录入学生信息, 编写程序, 录入资料系统

    二. 构造方法的重载

    1. 定义

      • 和成员方法的重载一样, 方法名相同,参数列表不同
      • 需要注意的是, 只要是构造方法, 方法名一定是相同的,也就是说构造方法的重载只是参数列表不同
    2. 演示

      public class Student {
       
       private String name ;
       
       //空参构造
       public Student(){
           
       }
       //有参的构造方法
       public Student(String name){
           this.name = name;
       }
       
      }
      
    3. 构造方法相互调用

      • 构造方法可以重载, 我们可能会写多个构造方法以应对不同的赋值动作, 已经写过的构造方法可以直接调用
      • 使用this() ,表示调用本类的构造方法
      • this()必须写在第一行
      public class Student {
       
       private String name ;
       private int age;
       
       //空参构造
       public Student(){
           
       }
       //有参的构造方法
       public Student(int age){
           if(age>0&&age<150)
               this.age = age;
       }
       
       public Student(String name,int age){
           //调用构造方法
           this(age);
           this.name = name;
       }
       
      }
      
    4. 测试题

      • 判断下列方法是不是构造方法重载
      public class Student {
       
       private String name ;
       private int age;
       
       
       public Student(){
           
       }
       
       public Student(int age){
           this.age = age;
           
       }
       
       public void Student(String name,int age){
           this.name = name;
           this.age = age;
       }
       
       public Student(String name){
           this.name = name;
           return ;
       }
      }
      

    三. 类成员之间的相互调用

    1. 定义

      • 成员变量一般来说都是为了成员方法服务的
      • 成员方法可以根据成员属性的不同做出不同的应对
    2. 演示

      • 定义长方形类, 根据长方形宽高的不同来计算面积和周长
      public class Rectangle {
       
       private int high;
       private int with;
       
       public Rectangle(int high,int with){
           this.high = high;
           this.with = with;
       }
       //获取面积
       public int getArea(){
           return high*with;
       }
       //获取长方形的周长
       public int getLength(){
           return (high+with)*2;
       }
       
       public int getHigh() {
           return high;
       }
       public void setHigh(int high) {
           this.high = high;
       }
       public int getWith() {
           return with;
       }
       public void setWith(int with) {
           this.with = with;
       }
       
      }
      
    3. 测试题

      • 设置员工类, 有属性 日工资, 工作天数, 绩效等级
      • 提供计算员工工资的方法

    四. 代码块

    1. 定义

      • 代码块就是定义一个无名称的代码块, 用{ } 括起来
    2. 分类

      • 局部代码块 : 方法中
      • 构造代码块 : 类中方法外
      • 静态代码块 : 类中方法外
      • 同步代码块 : 作用域多线程中
    3. 应用

      • 局部代码块
        • 限定局部变量的生命周期, 及早释放, 提高内存利用率
        • 在方法中创建一个域, 限制变量的作用范围
      • 构造代码块
        • 创建对象时候优先于构造方法执行, 多个构造方法中相同的代码存放到构造代码块中, 节省代码量
      • 静态代码
        • 给构造代码块加上static关键字就变成了静态代码块, 用于类的初始化, 在类加载的时候就执行, 并且只在类加载的时候执行一次, 一般用于加载驱动
      public class Demo {
       
       //构造代码块
       {
           System.out.println("构造代码块执行了");
       }
       //静态代码块
       static{
           System.out.println("静态代码块执行了");
       }
       
       public void method(){
           //局部代码块
           {
               System.out.println("局部代码块执行了");
           }
       }
      }
      
    4. 测试题

      • 定义一个餐桌类, 有三个属性, 热菜, 凉菜, 汤
      • 定义重载的构造方法,来接收菜, 但是上菜之前必须要给桌子铺上餐布
    5. 对象初始化顺序问题

      • 成员变量 ==> 构造代码块 ==> 构造方法
      • 成员变量和构造代码谁在上面先执行谁(正常开发是,一般成员变量写在最上面)
    静态.png 类与对象.png

    五. 静态(static)

    1. 定义

      • 用于修饰类的成员, 表示静态
      • 一旦被修饰, 类的成员将不再属于这个类创建的对象
    2. 特点

      • 随着类的加载而加载
      • 优先于对象存在
      • 被类的所有对象共享
      • 通过类名调用
        • 其实他本身也可以通过对象名调用
        • 推荐使用类名调用
      • 优先于非静态成员
      • 类的所有静态成员都存储于静态方法区
    3. 演示

      public class Demo {
       //静态成员变量
       public static double PI = 3.1415926;
       //静态方法
       public static int getAbs(int num){
           return num>0?num:-num;
       }
      }
      
      
    4. 测试题

      • 判断打印结果
      public class Demo {
       
       {
           System.out.println("构造代码块");
       }
       
       static {
           System.out.println("静态代码块");
       }
      }
      
      
    5. 初始化顺序

      • 静态成员变量 ==> 静态代码块 ==> 成员变量 ==> 构造代码块 ==> 构造方法
      • 静态成员变量和静态代码块(构造代码块)谁写在前面谁先执行

    六. 静态的使用

    1. 定义

      • 通过对静态的了解, 我们得知, 存放于方法区之中,属于类,我们也称之为类成员
      • 当一个类的成员被频繁使用的时候, 就可以写成静态的,以便于提高效率
      • 当一个属性或方法被所有的对象共享的时候
    2. 使用格式

      • 类名.成员变量名
      • 类名.方法名()
    3. 演示

      public class Demo {
       //静态成员变量
       public static String name = "小红";
       
       //静态成员方法
       public static void method(){
           System.out.println("静态方法");
       }
      }
      
      public static void main(String[] args) {
       
       //调用静态成员变量
       System.out.println(Demo.name);;
       //调用静态成员方法
       Demo.method();
      }
      
      
    4. 注意事项

      • 静态的成员在内存中只有一份
      • 所有的操作指向的都是同一个静态成员
      • 可以使用对象名调用, 但是不推荐
      • 静态可以极大的提升运行的效率
      • 静态随着类的存在而存在, 随着类的消亡而消亡, jvm不关闭, 静态就一直存在, 太多话 ,容易造成内存溢出
      • 频繁被使用的成员要写成静态的
    5. 测试题

      • 设计程序, 记录一个类创建对象的次数

    七. 静态和非静态

    1. this关键字的问题

      • 静态方法中无法使用this关键字, 因为静态方法调用的时候, 不需要对象
      • 非静态方法中可以使用this关键字, 因为非静态方法在调用的时候必须有对象
    2. 访问成员变量

      • 静态方法只能访问静态的成员变量, 如果要使用非静态的成员变量,必须先创建对象
      • 非静态的方法可以直接访问静态的成员变量,也可以直接访问非静态的成员变量
    3. 访问成员方法

      • 静态方法只能访问静态方法,如果想使用就必须要创建对象
      • 非静态方法可以直接访问静态方法,也可以直接访问非静态方法
    4. 简单记

      • 静态只能访问静态(直接调用)
    5. 演示

      public class Demo {
       
       static String name = "李四";
       int age = 18;
       
       public static void method1(){
           //静态方法可以直接访问静态成员方法
           System.out.println(name);
           
           //这里会报错
           //System.out.println(age);
           
           //静态要访问非静态的成员变量必须要创建对象
           Demo demo = new Demo();
           System.out.println(demo.age);
           
           //静态方法可以直接访问静态方法
           method3();
           
           //静态方法想要访问非静态方法必须要先创建对象
           demo.method4();
       }
       
       public void method2(){
           //非静态可以直接访问静态成员变量
           System.out.println(name);
           
           //非静态方法可以直接访问非静态的成员变量
           System.out.println(age);
           
           //非静态方法可以直接访问静态成员方法
           method3();
           
           //非静态方法可以直接直接方法非静态方法
           method4();
       }
       //静态方法
       public static void method3(){
           
       }
       
       //非静态方法
       public void method4(){
           
       }
      }
      
      

    八. main方法详解

    1. 格式

      • public static void main(String[] args) {}
    2. 详解

      • public 被jvm调用,访问权限足够大。
      • static 被jvm调用,不用创建对象,直接类名访问
      • void 被jvm调用,不需要给jvm返回值
      • main 一个通用的名称,虽然不是关键字,但是被jvm识别
      • String[] args 以前用于接收键盘录入的 arguments
    3. 演示

      java xxx hh hhh ss
      
      

    总结

    1. 构造方法
      • 特性 : 随着创建对象而自动执行 和创建对象这个动作时紧密相连的
      • 作用 :
          1. 优先于成员方法执行,
          2. 给方法运行时的必要成员变量赋值
    2. 构造方法的重载
      • 所有存在的可用的构造方法都是重载关系
      • 构造方法之间可以相互调用 this ()
    3. 类成员之间相互调用
      • 成员变量和成员方法之间是可以相互调用的
      • 构造方法可以调用成员变量和成员方法
      • 构造代码块也可以调用成员变量和成员方法
      • 成员变量和成员方法无法调用构造代码块和构造方法
      • 构造方法和构造代码块相互无法调用
    4. 代码
      • 局部代码块 : 写在方法内 及时释放资源
      • 构造代码块 : 优先于构造方法执行, 可以将构造方法中相同的代码提取出来,放到构造代码块中
      • 静态代码快 : 类加载时执行, 优先于对象, 一般用来注册驱动
      • 同步代码快 : 保证多线程的安全性
    5. 静态
      • 类加载的过程中,在初始化类的时候, 会将所有的静态存入静态方法区(能执行的就直接执行了), 独一份
      • 优先于对象, 更优先于所有非静态
      • 唯一的, 公用的
    6. 静态的调用
      • 静态只能调用静态 , 非静态可以调用静态
      • 因为静态存在的时候, 非静态不一定存在, 如果直接调用, 有危险, 虚拟机不允许
      • 非静态执行时,静态一定存在, 所以,可以放心的使用

    作业

    1. 第一题
      • 创建动物类, 定义种类, 性别属性
      • 从键盘录入数据, 通过构造方法存入对象中, 并调用对象的方法打印
    2. 第二题
      • 描述猫类 ,有属性name, color,sex,通过构造方法给猫的属性赋值(一个是波斯猫,一个是土猫,其他属性自定义)
      • 为猫类添加吃饭,抓老鼠方法创建两个猫的对象
      • 分别调用猫的吃饭,抓老鼠方法
    3. 第三题
      • 创建一个工具类, 定义方法用来将基本数据类型转换成字符串
    4. 扩展题
      • 定义一个动物类, 自定义属性
      • 定义吃饭和睡觉方法
      • 创建两个对象(小猫,小狗), 分别调用吃饭和睡觉方法
      • 打印结果是: 小猫吃小鱼干, 甜甜的睡着了. 小狗吃骨头, 憨憨的睡着了

    相关文章

      网友评论

          本文标题:Day08

          本文链接:https://www.haomeiwen.com/subject/ptgbwctx.html