JAVA第一阶段1-10天_定义一个变量记录天数为10 java-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44594263/article/details/110329797

*第一阶段知识点梳理**

1.JAVA运行机制：先编译后运行。.java源文件打包编译生成.class文件，class文件翻译运行。
2.赋值：同一方法中，变量名不允许重复。但是在不同方法中，变量名允许重复。
3.JAVA基本数据类型
整数类型：byte short int long
浮点类型: float double
字符型: char
布尔类型：boolean
4.基本数据类型间的转换问题：隐式转换（自动转换）小转大，自动转。boolean类型和其他数据类型都是不兼容的，byte–>short–> int–> long–> float–>double。、
5.封装的好处：1.提高安全性。2.提高重用性。
6.private关键字：是一个权限修饰符，用于修饰成员变量和成员函数，被私有化的成员只能在本类中访问。想要修改只能对外提供公共的get和set方法。
7.创建对象的流程：

把Person.class文件加载进内存
在栈内存中，开辟空间，存放变量p
在堆内存中，开辟空间，存放Person对象
对成员变量进行默认的初始化
对成员变量进行显示初始化
执行构造方法（如果有构造代码块，就先执行构造代码块再执行构造方法）
堆内存完成
把堆内存的地址值赋值给变量p ，p就是一个引用变量，引用了Person对象的地址值
8.构造方法：构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的创建或者对象的初始化。当类实例化一个对象时会自动调用构造方法。
9.构造代码块>局部代码块：
1.在类的内部，方法外部的代码块。
2.通常用于抽取构造方法中的共性代码。
3.每次调用构造方法前都会调用构造代码块。
4.优先于构造方法加载。
10.this关键字
this代表本类对象的一个引用对象。构造函数中，this()必须放在第一行。
11.继承
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。提高复用性：只要继承父类，就能有一样的功能。
特点：
1、使用extends关键字
2、相当于子类把父类的功能复制了一份
3、 java只支持单继承
4、继承可以传递（爷爷，儿子，孙子的关系）
5、不能继承父类的私有成员
6、继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
7、像是is a 的关系
12.super关键字
1、通过super关键字可以使用父类的内容
2、 super代表父类的一个引用对象
3、如果用，必须出现在调用位置的第一行
13.方法的重写
1、继承后，子类就拥有了父类的功能
2、那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能
3、子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能
注意：
1、父类中的私有方法不能被重写
2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限
14 this和super的区别
1、 this代表本类对象的引用，super代表父类对象的引用。
2、 this用于区分局部变量和成员变量
3、 super用于区分本类变量和父类变量
4、 this.成员变量 this.成员方法() this(【参数】)代表调用本类内容
5、 super.成员变量 super.成员方法() super(【参数】)，代表调用父类内容
6、 this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行，同时出现的话，到底第一行放谁呢。。
15. 重写与重载的区别（Overload和Override的区别）
1、重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
2、重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
3、重写是父类与子类之间多态性的一种表现
4、重载是一类中多态性的一种表现
16.static关键字
1.可以修饰成员变量成，成员方法
2.随着类的加载而加载，优先于对象加载
3.只加载一次，就会一直存在，不在开辟新空间
4.全局唯一，全剧共享
5.可以直接被类名调用
6 静态只能调用静态，非静态可以随意调用
7 static不能和this或者super共用，因为有static时可能还没有对象
17.成员变量和局部变量的区别（变量的就近原则）
成员变量：类里方法外，作用范围是整个类，可以不初始化也可以有默认值
局部变量：方法里，作用范围就是方法里，出了方法不认识，必须初始化
18.面试常见算法
合并算法，二分算法，快速算法等，冒泡最常见
19.final关键字
1、被final修饰的类，不能被继承
2、被final修饰的方法，不能被重写
3、被final修饰的变量是个常量，值不能被更改
4、常量的定义形式： final 数据类型常量名 = 值
20.静态变量和实例变量的区别
在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。
21.向上转型和向下转型
向上转型：父类的引用指向子类对象Parent p=new Child();
说明：向上转型时，子类对象当成父类对象，只能调用父类的功能，如果子类重写了父类的方法就根据这个引用指向调用子类重写方法。
向下转型(较少)：子类的引用的指向子类对象，过程中必须要采取到强制转型。
Parent p = new Child();//向上转型，此时，p是Parent类型
Child c = (Child)p;//此时，把Parent类型的p转成小类型Child
//其实，相当于创建了一个子类对象一样，可以用父类的，也可以用自己的
说明：向下转型时，是为了方便使用子类的特殊方法，也就是说当子类方法做了功能拓展，就可以直接使用子类功能。
22.抽象类
1.Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。该没有方法体的方法我们称之为抽象方法，含有抽象方法的类我们称之为抽象类。
2.修饰符 abstract 返回值方法名(参数列表);
3.抽象类本身不可以实例化，用于子类的实例化。
23.接口
概念：Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
特点：
1、接口中都是抽象方法
2、通过interface关键字创建接口
3、通过implements让子类来实现
4、可以理解成，接口是一个特殊的抽象类
5、接口突破了java的单继承的局限性
6、接口和类之间可以多实现，接口和接口之间可以多继承
7、接口是对外暴露的规则，是一套开发规范
8、接口提高了程序的功能扩展，降低了耦合性
注意：
1.接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：public static final
2.接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。

总结

1、类和类的关系：继承 extends / 单继承 / 单根继承
– 继承的意义：为了提高代码的复用性，减少了代码的编写提高开发效率。
– 方法重写的意义：在不修改父类源码的前提下，在子类中重写业务，从此使用的就是重写后的功能。
– 要求子类的方法声明和父类一样，只要改方法体。
– 有了继承有了重写就产生了多态，多态的意义：为了统一程序的调用标准，标准就是父类。
– 多态也就是向上转型/向上造型。
– 向下造型的意义：很少用，相当于想要使用子类的特殊功能，还不如直接创建子类对象简单。
– class A extends B
– 其中，A和B都是类，A是子类，B是父类，A就拥有了B的所有功能(除了私有的和构造方法)
– 其他知识点：this 和super ，构造方法，各种代码块…

2、类和接口关系：实现implements / 单实现 / 多实现
– class A implements B,C
– 其中，A是实现类,B和C是接口
– 要求A 可以把 B 和C 接口里的所有抽象方法都重写掉，否则 A 就是抽象类
– 接口不能创建对象
– 接口里没有构造方法，接口里都是常量，接口里都是抽象方法
3、接口和接口关系：继承extends / 单继承 / 多继承
– 接口的多继承的关系，打破了java单继承的局限性
– interface A extends B,C
– 其中，A B C 都是接口，A是子接口，同时拥有B和C接口里的所有功能
– class AImpl implements A
– 要求AImpl需要重写A接口里的所有方法(是包含B和C接口的所有方法)，否则就是抽象类
4、接口和抽象类的区别！！！
– 相同点：都是抽象层，都不能实例化
– 不同点：
– 1、抽象类用abstract关键字描述，接口用interface
– 2、子类和抽象类之间是extends关系，实现类和接口之间是implements关系
– 3、抽象类中可以有构造方法，接口里不能出现构造方法
– 4、抽象类里可以有变量，接口里没有变量全都是静态的常量
– 5、接口里定义常量的语法：public static final String NAME=“jack”，会为变量自动拼接public static final
– 6、抽象类里可以有普通方法也可以有抽象方法，接口都是抽象方法
– 7、抽象类和子类之间是继承关系，而且java中，只支持单继承
– 8、接口突破了java单继承的局限性，因为接口可以多继承也可以多实现，甚至可以继承的同时多实现
– 9、接口的复杂用法
– 多继承： interface A extends B,C 其中A是子接口，同时拥有自己的和BC的功能
– 多实现： class AImpl implements M,N,O,P 其中AImpl是实现类，需要同时重写MNOP的所有抽象方法，否则就是一个抽象类
– 继承的同时多实现： class AImpl extends Object implements M,N 一定是先继承后实现

单例模式

概念：单例模式有很多好处，比如可节约系统内存空间，控制资源的使用，其中单例模式最重要的是确保对象只有一个，简单来说，保证一个类在内存中的对象就一个，RunTime就是典型的单例设计，我们通过对RunTime类的分析。

package java.lang;
public class Runtime {
    //1、创建静态的全局唯一的对象
    private static Runtime currentRuntime = new Runtime();
    //2、私有构造方法， 
    /** Don't let anyone else instantiate this class */
    private Runtime() {}
//3、通过自定义的静态方法获取实例
    public static Runtime getRuntime() {
        return currentRuntime;
    }
}

饿汉式
目的：控制外界创建对象的个数只能创建1个对象
开发步骤：
1、私有化构造方法
2、在类的内部创建好对象
3、对外界提供一个公共的get()，返回一个已经准备好的对象

package cn.tedu.single;
//测试单例设计模式  
public class Test8_Single {
    public static void main(String[] args) {
       Single s = Single.get();
       Single s1 = Single.get();
       //get()多少次，内存中使用的都是同一个对象
       System.out.println(s);//cn.tedu.single.Single@15db9742
       System.out.println(s1);//cn.tedu.single.Single@15db9742
    }
}
class Single{
//  1、私有化构造方法，不让外界直接new
    private Single() {}
//  2、在类的内部，创建好对象
    //static ：静态只能调用静态
    static private  Single s = new Single();
//  3、对外界提供一个公共的get()，返回一个已经准备好的对象
//static是为了外界不通过对象访问而是通过类名直接方法  
    static public Single get(){
       //注意：静态只能调用静态
       return s;
    }
}

懒汉式

class Single{
//  1、私有化构造方法，不让外界直接new
    private Single() {}
//  2、在类的内部，创建好对象
    //static ：静态只能调用静态
    static private  Single s = null;
//  3、对外界提供一个公共的get()，返回一个已经准备好的对象
//static是为了外界不通过对象访问而是通过类名直接方法  
synchronized  static public Single get(){
       /注意：静态只能调用静态
       if(s==null){
           s = new Single();//会有安全问题
}
       return s;
    }
}