Java面向对象笔记3

包装类的使用

• 针对八种基本数据类型定义相应的引用类型-包装类（封装类）

• 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

• 掌握的：基本数据类型、包装类、String三者之间的相互转换

//基本数据类型--->包装类：调用包装类的构造器
public void test1(){
	int num1=10;
	//System.out.println(num1.toString());num1是基本数据类型，无法.toString
	Integer in1= new Integer(num1);
	System.out.println(in1.toString);
    //in1就是把基本数据类型包装起来的对象
}

//包装类--->基本数据类型：调用包装类的xxxValue（）
public void test2(){
   	Integer in1=new Integer()
    int i1=in1.Value();
    System.out.println(i1+1);
}

public void test3(){
//自动装箱
    int num2 = 10;
    Integer in1=num2;
//自动拆箱
int num3=in1;
}

//基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)
public void test4(){
    int num1=10;
    //连接运算
    String str1=num1+"";
    //方式2：调用String的valueOf(Xxxx xxx)
    float f1=12.3f;
    String str2=String.valueOf(f1);
    
    Double d1=new Double(12.4);
    String str3=String.valueOf(d1);
    System.out.println(str2);
    System.out.println(str3);
    //总结：无论是基本数据类型还是包装类都可以调valueOf()
    
    //String类型--->基本数据类型、包装类
    public void test5(){
        String str1="123";
        25---7:20s
    }
}

Static关键字的使用

1. static：静态的

2. static可以用来修饰：属性、方法、代码块、内部类

3. 使用static修饰属性：静态变量（类变量）

   • 属性，按是否使用是static修饰，又分为：静态属性 VS 非静态属性（实例变量）

     • 实例变量：我们创建了类的多个对象，每个对象都独立拥有一套类中的非静态属性。当修改其中一个对象的非静态属性时，不会导致其他对象中同样的属性值的修改。

     • 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是调用修改过了的静态变量；

   • static修饰属性的其他说明：

     1. 静态变量随着类的加载而加载。可以通过“类.静态变量”的方式进行调用

     2. 静态变量的加载要早于对象的创建

     3. 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。

     4. 类变量 实例变量

        类 yes no

        对象 yes yes

4. 使用static修饰方法：静态方法

   1. 随着类的加载而加载，可以通过“类.静态方法”的方式进行调用

   2. 静态方法 非静态方法

      类 yes no

      对象 yes yes

   3. 静态方法中，只能调用静态的方法或属性

      非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

5. static注意点：

   1. 在静态的方法内，不能使用this关键字、super关键字

   2. 关于静态属性和静态方法的使用，大家都从声明周期的角度去理解

6. 开发中，如何确定一个属性是否要声明为static的？

   • 属性是可以被多个对象所共享的，不会随着对象的不同而不同的

   开发中，如何确定一个方法是否要声明为static的？

   • 操作静态属性的方法，通常设置为static的

   • 工具类中的方法，习惯上声明为static的。比如：Math、Arrays、Collections

单例设计模式：

单例模式的优点：由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用时直接产生一个单例对象，然后永久驻留内存的方式来解决。

1. 所谓类的单例设计模式，就是采取一定的方法保证整个的软件系统中，对某个类只能存在一个对象实例

2. 如何实现？

   1. 饿汉式

      package com.atguigu.java;
      //单例模式
      public class SingletonTest {
          public static void main(String[] args) {
              Bank bank1=Bank.getInstance();
              Bank bank2=Bank.getInstance();
      ​
              System.out.println(bank1==bank2);
          }
      }
      ​
      //饿汉式
      class Bank{
          //1.私有化类的构造器
          //目的：避免在Bank类的外面调用构造器
          private Bank(){
      ​
          }
          //2.内部创建类的对象
          //静态方法中只能调用静态的结构，所以instance也需要static
          //4.要求此对象也必须声明为静态的
          private static Bank instance=new Bank();
      ​
          //3.提供公共的静态的方法，返回类的对象
          public static Bank getInstance(){
              return instance;
          }
      }

   2. 懒汉式

      package com.atguigu.java;
      //单例模式的懒汉式
      public class SingletonTest2 {
          public static void main(String[] args) {
              Order order1= Order.getInstance();
              Order order2=Order.getInstance();
      ​
              System.out.println(order1==order2);
          }
      }
      ​
      class Order{
          //1.私有化类的构造器
          private Order(){
      ​
          }
      ​
          //2.声明当前类的对象，没有初始化
          //4.此对象也必须声明为static的
          private static Order instance=null;
      ​
          //3.声明public\static的返回当前类的对象的方法
          public static Order getInstance() {
              if (instance == null) {
                  instance =new Order();
              }
              return instance;
          }
      }

3. 区分懒汉式和饿汉式

   饿汉式：坏处：对象加载的时间过长。

   好处：饿汉式是线程安全的。

   懒汉式：好处：延迟对象的创建。

   坏处：目前的写法是不安全的。

理解main方法的语法

1. main（）方法作为程序的入口

2. main（）方法也是一个普通的静态方法

   public class MainTest {
       public static void main(String[] args) {
           Main.main(new String[100]);
   ​
           MainTest test=new MainTest();
           test.show();
       }
       private void show() {
       }
   }
   ​
   class Main{
       public static void main(String[] args) {
           for (int i = 0; i < args.length ; i++) {
               args[i]="args_"+i;
               System.out.println(args[i]);
           }
       }
   }

3. main（）方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

代码块

1. 代码块的作用：用来初始化类、对象

2. 代码块如果有修饰的话，只能使用Static。

3. 分类：静态代码块 VS 非静态代码块

4. 静态代码块

   • 内部可以有输出语句

   • 随着类的加载而执行，并且它只执行一次

   • 如果一个类中定义了多个代码块，则按照声明的先后顺序执行

   • 静态代码块的执行>非静态代码块的执行

   • 静态代码块内只能调用静态的属性、静态方法，不能调用非静态的结构

   • 作用：初始化类的信息

5. 非静态代码块

   • 内部可以有输出语句

   • 随着对象的创建而执行，每创建一个对象就执行一次非静态代码块

   • 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行

   • 非静态代码块内可以调用静态属性、静态方法，或非静态的属性、非静态的

   • 作用：可以在创建对象时，对对象的属性进行初始化

对属性可以赋值的位置：

1. 默认初始化

2. 显示初始化

3. 构造器中初始化

4. 有了对象以后，可以通过“对象.属性”或“对象.方法”的方式，进行赋值

5. 在代码块中赋值