学习日记-day03（java基础）

这两天学校考试，忙于复习，就把java 先放下了，今天继续学习。

一.面向对象

1.向下转型：将父类引用转换为子类引用。（前提是，该父类引用指向的是目标子类对象）

   

  public static void main(String[] args) {   
          Animal animal=new Dog();
          Dog dog=(Dog)animal;   //只有该animal引用指向Dog对象时,才能转为该对象引用
          
    }

细节: 属性没有重写之说,也就是向上转型时,属性的值要看父类.

    public static void main(String[] args) {
          Animal dog=new Dog();
          System.out.println(dog.age);
    }
}
 class  Animal{
    int age=10;
 }
 class Dog extends  Animal{
    int age=20;
 }

输出的值为10,也就是父类Animal的值

2.instanceof: 一个关键字,用来判断一个父类引用指向的是否为某个子类.

3.Object类:

       (1)==和equals()的对比: ==是一个操作符,可以判断基本类型和引用类型, 医用类型时,比较的是引用地址是否相同. equals是Object类中的方法,只能判断引用类型,并且判断的是引用地址是否相同（源码就是通过==判断的）,子类中往往重写该方法,用于判断内容是否相等.比如:Integer，String。

     （2）hashCode():

             (1)提高具有哈希结构的容器的效率！

             (2) 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！

             (3) 两个引用，如果指向的是不同对象，则哈希值是不一样的

             (4) 哈希值主要根据地址号来的！， 不能完全将哈希值等价于地址。

      (3) toString():object中默认的是:全类名+@+哈希值的十六进制,子类往往重写toString方法,用于返回对象的属性信息,当直接输出对象引用时,toString方法会被默认调用.

     (4)finalize(): 在gc要销毁对象前主动调用的方法.

二.类变量和类方法

1.类变量：类变量也叫做静态变量，是该类所有变量所共享的变量，该类所有对象访问该变量时访问的同一个变量，修改也是修改的同一个变量。

2.如何定义类变量：  访问修饰符 static 数据类型 变量名；

3.如何访问类变量：(1) 类名.类变量名 (2) 对象.类变量名

4.类变量在类加载时就已经初始化了.

5.类方法也就静态方法,类方法和普通方法都随着类加载而加载,存储在方法区中.

6.类方法中不能直接调用实例变量,需要通过创建对象调用.但可以直接访问静态变量.

7.普通方法既可以直接访问静态变量也可以直接访问实例变量.

8.定义类方法: 访问修饰符 static 返回类型  方法名

9.访问静态方法: 通过类名调用或者通过对象调用.

main方法: (1)是由虚拟机调用的,所以该方法的访问权限必须是public

                 (2)调用main方法时不用创建该类对象,所以该方法是static(静态方法)

                 (3)在main方法中可以直接访问该类的静态变量和静态访问，但是不能直接访问实例变量，因为main方法是静态的。

三.代码块

1.代码块属于类中的成员,类似以方法,将逻辑语句封装在方法体中,通过{}包围起来。相当于只有方法体的方法，在加载类时(静态代码块)或者创建对象时隐式调用

2.基本语法{

}

3.语法块的好处:当多个构造器中都有重复的语句,可以抽取公共部分放在代码块中,降低代码冗余.

4.static代码块也叫静态代码块,作用是对类进行初始化,而且随着类的加载而执行,并且只会执行一次,普通代码块是没创建一个对象就执行一次代码块.

5.类加载:  (1)new该类的对象的时

                (2)调用静态变量或者静态方法时

                (3)子类创建实例时会加载父类.

6.静态代码块相当于只有方法体的静态方法,普通代码块相当于只有方法体的普通方法,只不过他们的调用都是隐士的,静态代码块在类加载时调用且只在类加载时执行一次,而普通代码块每次创建对象都要执行一次.

7.创建一个对象时,在一个类调用顺序是:

        (1)父类的静态代码块-->子类静态代码块-->父类普通代码块-->父类构造方法--.子类普通代码块-->子类构造方法.(先加载父类再加载子类,然后实例化父类对象,最后实例化子类对象)

        (2)当有多个静态代码块或者多个普通代码块时,是按照定义的顺序执行的.

8.构造方法中最前面其实隐含了super()和调用普通代码块.

四.单例模式

1.单例模式: 就是采取一定的方法保证某个类只有一个实例对象.

2.单例模式有两种方法:(1)饿汉式  (2)懒汉式.

3.饿汉式:   不论使不使用实例对象实例对象都会创建

实现:(1)首先构造器应该是私有的,也就是不让别人随便new对象

        (2)定义一个成员变量,变量类型为本类,并初始化一个new的对象实例,且该成员变量是私有的,我们先不管该变量是静态的还是非静态的.

       (3)定义一个公共方法用来获取这个变量,因为我们是要通过这个方法获取实例,所以这个方法必须为静态方法,只有这样我们才能在没有实例对象的情况下调用它,既然这个方法是静态的,那么我们要在这个方法中访问我们定义的对象变量,那么那个对象变量我们也就只能是静态的.

代码实现:

 class Dog {
      private static Dog dog=new Dog();  //内部创建的对象实例,私有化的
      
      private Dog(){}  //私有的构造方法 
      public static Dog getInstance(){  //公共的用来获取对象实例的方法
          return dog;
      }
 }

 4.懒汉式: 当想获取该类的对象实例时才创建对象实例.

实现步骤:(1).私有化的构造方法

                (2).私有的此对象变量,只定义不创建.

                 (3).获取对象实力的方法,如果对象变量为空时,new一个对象,不为空时则直接返回.

代码实现:

 class Dog {
      private static Dog dog;  //内部创建的对象实例,私有化的

      private Dog(){}  //私有的构造方法
      public static Dog getInstance(){  //公共的用来获取对象实例的方法
          if(dog==null){   //判断是否为空
              dog=new Dog();
              return dog;  
          }else{
              return dog;
          }
      }
 }

5.懒汉式和饿汉式的区别

(1)饿汉式在类加载时就创建对象实例,懒汉式在调用获取对象实例的方法时才创建实例对象.

(2)饿汉式没有线程安全,懒汉式有线程安全.(当多个线程同时调用获取对象实例的方法时,可能会并发判断当前对象变量是否为空,此时它们判断都为空,就会创建多个对象实例)

(3)饿汉式会造成资源浪费,懒汉式不会造成资源浪费.

五.final关键字

1.final可以修饰属性,类,方法,局部变量

2.final修饰类时,表示该类不能继承.

3.final修饰方法时,表示该方法不能被重写.

4.final修饰属性和局部变量时,表示该变量不能被修改.但可以继承.

5.final修饰的属性在定义时,必须赋初值.(可以在定义时赋值,或者在代码块中赋值,或者在构造方法中赋值)

6.如果有一个类是final修饰时,就不用再用final该类中的方法了,没有必要.

7.final不能修饰构造器.

8.当final和static搭配使用时效率更高,不会导致类加载.底层编译器做了优化(也就是访问有final和static修饰的变量时不会导致类加载

六.抽象类

1.抽象方法: 当某个方法要声明但是不知道怎么实现时,可以将其声明为抽象方法.

2.抽象方法的定义 :  修饰符  abstract 返回类型 方法名

3.一个类如果有抽象方法时,该类必须为抽象类,抽象类不一定有抽象方法.

4.抽象类的定义:    abstract class 类名

5.抽象类不能被实例化.

6.抽象类只能修饰类和方法.

7.如果一个类继承了抽象类,那么必须实现抽象方法,除非子类也将该方法定义为abstract.

8.抽象方法不能有方法体

9.abstract不能和static 、final  、 private  修饰

七.接口

1.接口:接口就是定义一些没有实现的方法(抽象方法)到一起,让其他类实现.

2.接口的定义  interface 接口名

3.jdk1.7之前接口中的方法都是抽象方法(也就是没有方法体),jdk8之后接口类可以有静态方法.

4.接口中的方法都是public和abstract修饰的,可以不写,编译器会默认带上.

5.接口中可以有变量,但是必须为public static fina l 的常量,

6.接口不能实例化.

7.一个普通类实现接口,必须实现接口中的所有方法.抽象类实现接口时,可以不实现接口中的方法

8.一个类可以同时实现多个接口,一个接口可以继承多个接口.

9.继承类和实现接口的区别:

   (1) 继承的价值在于解决代码得到复用性和可维护性.

   (2) 接口的价值在于设计各种规范(方法),让其他类实现,更加的灵活.可以解耦

今天写的一道算法题:

(1)  在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

方法1:

public int findRepeatNumber(int[] nums){
        Map<Integer,Integer> map=new HashMap<>();
        for (int i = 0; i < nums.length ; i++) {
            if (map.containsKey(nums[i])){
                return nums[i];
            }
            map.put(nums[i],i);
        }
        return -1;
    }

方法2:

public int findRepeatNumber(int[] nums){
        for (int i = 0; i < nums.length; i++) {
            if(nums[i]!=i){
                while(nums[i]!=i){
                    if(nums[nums[i]]==nums[i]){
                        return nums[i];
                    }
                    int temp=nums[i];
                    nums[i]=nums[nums[i]];
                    nums[temp]=temp;
                }
            }
        }
        return -1;
    }