嵌入式软件开发培训笔记——Java第三天(方法重载、对象的构造与初始化过程分析、封装等)

最新推荐文章于 2024-09-21 10:38:43 发布
最新推荐文章于 2024-09-21 10:38:43 发布
阅读量709 收藏
点赞数
分类专栏： Java编程 文章标签： java 方法重载 对象的构造与初始化过程分析 封装 自动拆箱装箱
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN85391440/article/details/45397559
版权
一、掌握方法重载(Overload)
    同一个类中方法名相同时，称为方法的重载(Overload)
    特点：1、参数列表不同
                    1）参数类型不同
                    2）参数的个数不同
              2、不考察返回值类型
    例：
    package reload;
    public class Reload {
     public static void main(String[] args) {
 
          Reload test = new Reload();
          int x = test.add(22, 15);
          int y = test.add(22,11,33);
          float z = test.add(2.5f, 6.5f);
 
          System.out.println(x);
          System.out.println(y);
          System.out.println(z);
     }
 
         public static int add(int a, int b){
              return a + b;
         }
 
         public static int add(int a, int b, int c){
              return a + b + c;
         }
 
         public static float add(float a, float b){
              return a + b;
         }
    }

    构造器的重载
    
二、this关键字
    指本类对象的引用
    （1、构造器中指该构造器所创建的新对象    2、方法中指调用该方法的对象）
    用法：
    1、在类本身的方法或构造器中引用该类的实例变量和方法
    2、将当前对象作为参数传递给其它方法或构造器
    3、用来调用其他的重载的构造器

三、对象的构造和初始化过程分析
    内在分配，缺省的初始化进行
    实例变量的初始化如下递归的进行：
    1、设置实例变量的值为缺省的初始值
    2、调用对象的构造器，绑定构造器参数
    3、如果构造器中有this()调用，则根据this()调用的参数调用相应的重载构造器，然后，转到步骤5;否则转到步骤4.
    4、除java.lang.Object类外，调用父类中的初始化块初始化父类的属性，然后调用父类构造器，如果在构造器中有super()调用，则根据super()中的参数调用父类中相应的构造器。
    5、使用初始化程序和初始化块初始化成员。
    6、执行构造器方法体中其他语句。

    初始化块
    它指的是类中中的“游离块”——不属于变量声明、不属于方法、不属于构造器，但需要用{}单独括起来。
    不管使用哪个构造器创建对象，它都会被首先运行，然后才是构造器的主体部分被告执行。
    初始化代码块：直接在类中定义，使用期{}括起来的语句。在构建对象时首先执行，它要先于当前类的构造器执行。
    执行步骤：1、父类的初始化块    2、父类的构造器    3、子类的初始化块    4、子类的构造器
    注：以上四个步骤不是线性执行，它们之间具有调用关系。
    例：
    
person.java
teacher.java
test.java
package person_teacher;
public class person {
 String name;
 String sex;
 int age;
 
 public person(){
  System.out.println("构造器person()被调用");
 }
 
 public person(String theName){
  System.out.println("构造器person(String theName)被调用");
  name = theName;
  System.out.println("name="+name+",age="+"age"+"sex="+sex);
 }
 
 public person(String theName, int theAge){
  System.out.println("构造器person(String theName, int theAge)被调用");
  name = theName;
  age = theAge;
  System.out.println("name="+name+",age="+"age"+"sex="+sex);
 }
 
 {
  name = "Tony Blair";
  age = 50;
  sex = "Female";
  System.out.println("\nperson初始化块执行后：name="+name+",age="+age+"sex="+sex);
 }
}
package person_teacher;
public class teacher extends person {
 String department;
 int schoolAge;
 
 teacher(){
  System.out.println("构造器teacher()被调用");
 }
 
 teacher(String name){
  super(name);
  System.out.println("构造器teacher(String name)被调用");
 }
 
 teacher(int theSchoolAge){
  schoolAge = theSchoolAge;
  System.out.println("构造器teacher(int theSchoolAge)被调用");
 }
 
 teacher(String theDepartment, int schoolAge){
  this(schoolAge);
  department = theDepartment;
  System.out.println("构造器teacher(String theDepartment, int schoolAge)被调用");
 }
 
 {
  department = "教务部";
  System.out.println("\nteacher初始化块执行后:name="+name+",age="+age+",sex="+sex);
 }
}
package person_teacher;
public class test {
 public static void main(String args[]){
  teacher t1 = new teacher();
  System.out.println("----------------------");
  teacher t2 = new teacher("Tom");
 }
}

四、封装类
问题：如何将字符串的“1234”转换成整数1234?如何将1234转换成十六进制？二进制？八进制？
以上问题需要使用封装类Integer的方法
API文档Integer类中public static int parseInt(String s);
示例1：字符串转整型，其他API也在Integer类中查找。
    package c1234;
    public class Test { 

     public static void main(String[] args) {
          String str = "1234";
          int x = Integer.parseInt(str);
          x++;
          System.out.println(x);
     }
    }

五、自动装箱/拆箱    （JDK5.0以后才有这个说法）（只限于封装类）
把基本的数据类型赋值给一个封装类的引用变量，称为自动装箱。
（Integer iObject = new Integer(100);Integer iObject = 100;）
指导一个引用变量赋值给简单数据类型变量，称为自动拆箱。
(int i = new Integer(100);)

示例1：
    package c1234;   
    public class Test {      
     public static void main(String[] args) {
          Integer i = new Integer(10);
          Integer j = new Integer(10);
          System.out.println(i == j);        // i与j分别指向的内存的地址
 
          Integer m = 100;
          Integer n = 100;
          System.out.println(m == n);    //m与n指向同一个内存
 
          Integer p = 200;
          Integer q = 200;
          System.out.println(p == q);    //值超出了赋值范围（-127~128），p、q各自重新new了一个对象
     }
    }
    结果分别为：false——true——false

六、==和equals()
示例1：

上例中Animal类结果都为false,是因为：
equals在object类中这个方法实现代码
    public boolean equals(Object obj){
        return (this == obj)
    }
就是说，这个方法在Object类中使用==实现的，它们是等价的。

而在String类中，程序运行的时候，由String类中的equals方法覆盖了Object中的equals方法，此时equals比较的是字符序列是否相等，==用来比较str1、str2是否指向同一个内存。 （面试常问题）
    equals方法在实际应用时可以自定义改写


七、toString()方法
是Object类中的方法
API文档Object类中public String toString();
返回值为：getClass().getName() + '@' + Integer.toHexString(hashCode())
                类名的完整引用+‘@’+  （ hashCode用来标识对象）
示例1：“会调用其自身的toString函数

示例2：重写的方法原理与上例一样
 


八、可变参数
    1、方法的参数类型相同
    2、使用...来表示可变参数
    3、可变参数可以看作是一个数组对象
示例1：


九、新型的for循环用法
     这种for循环方式，可以应用于数组和集合的运算。相似于shell脚本的for循环。
    示例1：
    
    for x in (.........)
    do 
            ............
    done
    这种循环称为foreach方式，在C#中有这种关键字

作业：
1.已知1900年1月1日是星期一，从键盘中输出1900年以后的年、月、日，
 1）判断年月日的合法性
 2）并判断这一天是星期几
 3）并且打印出这个月份的月历，打印格式参见Windows操作系统。
mydate类 test类
public class Mydate {
 
 public int getDay(int year, int month, int day) {
  int daycount = 0;
  int leapflag = 0;
 
  if(year < 1900){
   return -1;
  }
 
  if((month < 1) || (month >12)) {
   return -1;
  }
 
  if(day < 1 || (day > 31)) {
   return -1;
  }
 
  for(int i = 1900; i < year; i++){
   if(((i%4 == 0) && (i%100 != 0)) ||(i % 400 == 0)) {
    daycount += 366;
   }else{
    daycount += 365;
   }
  }
 
  if(((year%4 == 0) && (year%100 != 0)) ||(year % 400 == 0)) {
   leapflag = 1;
   if((month == 2) && (day > 29)) {
    return -29;
   }
  }else{
   if((month == 2) && (day > 28)) {
    return -28;
   }
  }
 
  switch(month) {
   case 1: daycount += day;
     break;
   case 2: daycount += (day+31);
     break;
   case 3: if(leapflag == 1){
      daycount += (day + 60);
     }else{
      daycount += (day + 59);
     }
     break;
   case 4: if(leapflag == 1){
      daycount += (day + 91);
     }else{
      daycount += (day + 90);
     }
     break;
   case 5: if(leapflag == 1){
      daycount += (day + 121);
     }else{
      daycount += (day + 120);
     }
     break;
   case 6: if(leapflag == 1){
      daycount += (day + 152);
     }else{
      daycount += (day + 151);
     }
     break;
   case 7: if(leapflag == 1){
      daycount += (day + 182);
     }else{
      daycount += (day + 181);
     }
     break;
   case 8: if(leapflag == 1){
      daycount += (day + 213);
     }else{
      daycount += (day + 212);
     }
     break;
   case 9: if(leapflag == 1){
      daycount += (day + 243);
     }else{
      daycount += (day + 242);
     }
     break;
   case 10:if(leapflag == 1){
      daycount += (day + 274);
     }else{
      daycount += (day + 273);
     }
     break;
   case 11:if(leapflag == 1){
      daycount += (day + 304);
     }else{
      daycount += (day + 303);
     }
     break;
   case 12:if(leapflag == 1){
      daycount += (day + 335);
     }else{
      daycount += (day + 334);
     }
     break;
   default:break;
  }
  return daycount;
 }
 
 public void display_month(int year, int month, int fweek) {
  int leapflag = 0;
  int count = 0;
  System.out.println("周日\t周一\t周二\t周三\t周四\t周五\t周六");
 
  if(((year%4 == 0) && (year%100 != 0)) ||(year % 400 == 0)) {
   leapflag = 1;
  }
 
  if(month == 2) {
   if(leapflag == 1){
    for(int i = 1; i <= fweek; i++) {
     System.out.print("\t");
     count++;
    }
    for(int i = 1; i <= 29; i++) {
     System.out.print(i+"\t");
     count++;
     if(count % 7 == 0) {
      System.out.println();
     }
    }
   }else{
    for(int i = 1; i <= fweek; i++) {
     System.out.print("\t");
     count++;
    }
    for(int i = 1; i <= 28; i++) {
     System.out.print(i+"\t");
     count++;
     if(count % 7 == 0) {
      System.out.println();
     }
    }
   }
  }else if((month % 2 == 0) && (month != 2) && (month < 7)) {
   for(int i = 1; i <= fweek; i++) {
    System.out.print("\t");
    count++;
   }
   for(int i = 1; i <= 30; i++) {
    System.out.print(i+"\t");
    count++;
    if(count % 7 == 0) {
     System.out.println();
    }
   }
  }else if((month % 2 == 1) && ((month <= 7))) {
   for(int i = 1; i <= fweek; i++) {
    System.out.print("\t");
    count++;
   }
   for(int i = 1; i <= 31; i++) {
    System.out.print(i+"\t");
    count++;
    if(count % 7 == 0) {
     System.out.println();
    }
   }
  }else if((month > 7) && (month % 2 == 0)) {
   for(int i = 1; i <= fweek; i++) {
    System.out.print("\t");
    count++;
   }
   for(int i = 1; i <= 31; i++) {
    System.out.print(i+"\t");
    count++;
    if(count % 7 == 0) {
     System.out.println();
    }
   }
  }else if((month > 7) && (month % 2 == 1)) {
   for(int i = 1; i <= fweek; i++) {
    System.out.print("\t");
    count++;
   }
   for(int i = 1; i <= 30; i++) {
    System.out.print(i+"\t");
    count++;
    if(count % 7 == 0) {
     System.out.println();
    }
   }
  }
 }
}
import java.util.Scanner;
public class test {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int errorflag = 0;
  Scanner ymd = new Scanner(System.in);
  System.out.println("请输入年份:");
  int year = ymd.nextInt();
  System.out.println("请输入月份:");
  int month = ymd.nextInt();
  System.out.println("请输入日期:");
  int date = ymd.nextInt();
   
  Mydate dd = new Mydate();
  int countday = dd.getDay(year, month, date);
  if(countday == -1) {
   System.out.println("输入日期格式错误！");
   errorflag = 1;
  }else if(countday <= -28) {
   System.out.println("该月没有"+date+"日");
   errorflag = 1;
  }else{
   System.out.println("距1900年1月1日,总天数共"+countday+"天");
  }
   
  int weekflag = countday % 7;
  switch(weekflag) {
   case 1: System.out.println("星期一");
      break;
   case 2: System.out.println("星期二");
      break;
   case 3: System.out.println("星期三");
      break;
   case 4: System.out.println("星期四");
      break;
   case 5: System.out.println("星期五");
      break;
   case 6: System.out.println("星期六");
      break;
   case 7: System.out.println("星期日");
      break;
   default: break;
  }
 
  if(errorflag == 0) {
   countday = dd.getDay(year, month, 1);
   weekflag = countday % 7;
   
   dd.display_month(year, month, weekflag);
  }
 }
}

csdn85391440
关注
专栏目录
《面试笔记》——Java基础终结篇（吃透系列）
q66562636的博客
06-06 315
今天给大家带来我去年实习与秋招期间历经几十场面试总结下来的Java基础常考面试题，看看你能答对多少。这是本期的JVM面试题目录，不会的快快查漏补缺~面向过程：一件事该怎么做，注重实现过程，以过程为中心面向对象：实现对象是谁，只关心怎样使用，不关心具体实现（只关心实现对象是谁，有封装、继承、多态三大特性）封装：可以不用关心内部实现，具体构造，只需知道怎么操作它就是，比如电视，手机，将内部封装起来，直接使用多态：同一个方法调用，由于对象不同可能会有不同的行为。比如都是休息，张三是睡觉，李四是爬山等；或则具体场景
Java入门学习笔记——郝斌（一）概述及面向对象
凌凌凌凌的博客
06-12 1756
Java入门学习笔记-郝斌Java概述java的起源和发展java的特点java的应用领域java学习目标二级目录三级目录 Java概述 java的起源和发展 java的特点 简单易学 java的风格类似于C++，因此C++程序员初次接触Java语言，就会感到很熟悉。从某种意义上讲，Java语言是C及C++语言的一个变种，因此，C++程序员可以很快地掌握Java编程技术。 Java摒弃了C/C++中容易引发程序错误并且难以掌握的一些特性，如指针、结构、以及内存管理等。 Java提供了丰富的类库，可以帮助
java面向对象学习笔记——面试题
weixin_46271306的博客
02-14 108
一、什么是面向对象？什么是面向过程？ 面向过程：分析问题所需要的步骤，将实现的程序步骤化，使用的时候依次调用，看中的是中间的过程，每一个步骤都需要自己去完成（手洗衣服）     优点：性能比面向对象高，因为面向对象调用时需要进行实例化，开销比较大。 Eg：Linux操作系统、嵌入式开发、单片机      缺点：没有面向对象容易维护、易复用、易拓展 面向对象：将构成问题的事物分解成各个对象，将实现的程序模块化，不看中中间的过程和步
嵌入式学习笔记——M4的基本定时器
qq_41954556的博客
03-22 1609
STM32F407的基本定时器
黑马程序员Java笔记
m0_68735537的博客
03-14 2055
输出打印、参与运算、修改记录的值。
嵌入式c++软件开发第二讲笔记
时义龙的博客
01-04 167
c++封装： 封装：封装可以达到对外提供接口，屏蔽数据，对内开发数据 C语言中的封装：当单一变量无法完成描述需求的时候，结构体类型解决了这一问题。 C++的封装：class 封装的本质，在于将数据和行为，绑定在一起然后通过对象来完成操作。 类与对象 类的声明：类是一种用户自定义类型 class 类名称 { public： 公有成员（外部接口） private： 私有成员 protected: 保护成员 }； 权限修饰符：public、private（set/get）、protected 面向对象编程实例：栈
嵌入式软件开发第一讲笔记
时义龙的博客
01-04 231
C+ +概述 1、嵌入式中为什么需要C+ +? 2、C+ +就业方向 3、C+ +面向对象特点(面向过程VS 面向对象) 4、C++标准(C++98, C++11, C++14, C++17, C++20) 5、C++编译器(vs微软VS g++) (命名空间: vs命名名字:成员) g++ 6、命名空间(作用(命名冲突:全局变量、函数)、使用注意事项、义使用命名) 7、C++ 输入输出(printf ) 8、C++关键字register. using、 auto (类型推导:高效编程) const、 co
C/C++，嵌入式等面试笔记以及八股
jjh135445的博客
08-31 1155
C/C++，嵌入式等面试笔记以及八股
Java笔记01——JAVA基础部分
weixin_57155307的博客
05-20 376
一、Java相关概念： 1、Java的特点： (1)面向对象。（2）跨平台性。（3）多线程。（4）安全可靠。（5）自动回收内存。 2、JVM & JDK &JRE： （1）JVM： JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。 Java的运行过程如下： .java（源代码）-------->.class（字节码）--------&g
Java基础（韩顺平版）笔记详
04-30
- 构造函数用于初始化对象的状态。 - **继承** - 继承允许一个类继承另一个类的属性和方法。 - super关键字用于访问父类的成员。 - **封装** - 封装是将对象的属性和行为封装在一起的过程。 - 使用访问修饰符...
java学习笔记.zip
07-04
这些"java学习笔记.zip"包含的文件详细涵盖了Java的多个重要方面，包括基础、进阶以及与之相关的框架技术。以下是对每个文件内容的概览： 1. **10、JavaSE：IO流.pdf** Java标准版（JavaSE）中的输入/输出（IO）流...
【java学习笔记之（面向对象基础一：类、实例、方法）】
weixin_52106918的博客
07-06 267
学习并记录java中的面向对象部分，详细讲解类、实例和方法
嵌入式工程师成长之路（6）——程序设计
热门推荐
云轩阁
02-04 2万+
如果发现有一天对自己写的程序非常清楚他出来是什么样子，那么恭喜你此小节入门了
Java核心技术· 卷一（11版）笔记（第1-3章）
weixin_43647460的博客
10-22 603
Java是一种跨平台的编程语言，广泛应用于企业级应用、嵌入式系统、移动应用等领域。Java程序可以在不同的操作系统和硬件平台上运行，具有高效性、安全性、稳定性等特点。Java程序的编写需要使用Java开发工具，如Eclipse、NetBeans、IntelliJ IDEA等。编写完成后，Java程序需要通过编译器将其转换为字节码，然后再通过Java虚拟机（JVM）解释执行。Java程序的基本组成部分包括类、对象、方法、变量、运算符等，Java程序也支持面向对象编程的特性，如封装、继承和多态。
Arthas sysenv（查看JVM的环境变量）
最新发布
刘大猫
09-21 278
Arthas sysenv（查看JVM的环境变量）
Java企业面试题3
m0_74972727的博客
09-15 919
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 211
faiss版本 faiss-v1.7.4。
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 966
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值