实训--day22

今天没上课，自己耍了一天，复习了一会儿Java的基础。其实就是对之前自己看的视频的笔记的整理

1：private
1）私有，权限修饰符，用于修饰类中的成员（成员函数和成员变量）
   被私有修饰的成员只在本类中有效
   通过对外提供get set方法，被外界所访问。
2）私有并不是封装，只是封装的一种表现形式而已。
3）之所以对数据进行私有但是又提供访问方法，是为了在访问中加入逻辑判断等语句
   对访问的数据进行操作，提高代码的健壮性。


2：构造函数
1）对象一被建立，就会调用与之对应的构造函数，所以构造函数的作用就是给对象进行初始化
2）当类中自定义了构造函数之后，系统默认的无参构造函数就没有了。
3）构造函数和一般函数的区别：构造函数是在对象建立时就运行，用于初始化对象
                             而函数必须在对象对其进行调用的时候才会运行，是用于给对象添加功能的
                             构造函数只在对象建立时运行一次，而方法可以被多次调用。
4）定义时期：当分析事物时，如果该事物具备一些特性或者行为，那么就将这么内容定义在构造函数中


3：构造代码块
1）定义的是不同对象共性的初始化内容，所以也是用于给对象初始化的
2）对象一建立就运行，而且优先于构造函数执行
3）和构造函数的区别：代码块是给所有对象进行统一初始化的
                     构造函数是给对应的对象进行初始化的


4：this
1）代表的是它所在的函数所属对象的引用，即哪个对象在调用这个函数，this就指哪个对象


5：怎样理解面向对象的过程


6：面向对象的三大特征：继承，封装，多态
类和对象的关系：
1）现实生活中的对象，如张三，李四
2）想要描述的：提取对象中的共性内容，即对具体的抽象
映射到Java中，就是定义的类
具体对象就是对应Java堆内存中用new新建的实体。


*类就是对现实生活中事物的藐视，对象就是实实在在存在的实体


*属性对应类的中变量，行为对应类中的方法
*定义类其实就是在描述事物，就是在定义属性和行为，属性和行为共同成为类中的成员变量和成员方法
*成员变量：存在于堆内存中，因为对象的存在，才在内存中存在
*局部变量：存在于栈内存中

内存这块，还是没弄懂，明天研究下。

1：static
每一个应用程序中，都有共性的功能，将这些功能进行抽取，独立封装，以便复用


将方法静态后，可以方便于使用，但是该类还是可以被其他程序建立对象。
为了更为严谨，强制让该类不呢被建立对象，可以通过将构造函数私有化来完成。


什么时候使用静态？
从两方面下手，因为静态修饰的内容有成员变量和成员函数
1）当对象中出现共享数据时，该数据被静态所修饰
   对象中有特有数据，要定义成非静态，存在于堆内存中
2）当功能内部没有访问到非静态数据（对象的特有数据），该功能定义成静态的


静态的特点：
1）随着类的加载而加载，也是随着类的消失而消失，说明它的生命周期最长
2）优先于对象存在
3）被所有对象所共享
4）可以直接被类名调用


使用静态的注意事项：
1）静态方法只能访问静态成员变量，但是非静态方法可以访问静态成员变量和非静态成员变量
2）静态方法中不可以使用this，super关键字。因为静态优先于对象存在，而this基本上是用来代表本类对象的
3）主函数是静态的


静态的利弊：
1）利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每个对像中存储一份
2）弊：生命周期过长
       访问有局限性（静态只能访问静态）


静态代码块：随着类的加载而执行一次，且是优先于主函数，仅执行一次。


2：构造函数
对象一建立就会调用与之对应的构造函数
所以构造函数的作用就是用于给对象进行初始化
当一个类中没有定义构造函数时，系统会默认给该类加上一个空参数的构造函数
什么时候定义构造函数：当分析事物时，该事物存在一些特性或行为，那么将这些内容定义在构造函数内部


构造代码块：定义的是不同对象共性的初始化内容
            也是用于给对象进行初始化的
            对象一建立就运行，优先于构造函数执行
            构造代码块是给所有对象进行统一初始化的
            构造函数是给对应的对象进行初始化的


Person p=new Person("张三"，20);这句话都做了什么事情？
1）因为new用到了Person.class文件，所以会先找到Person.class文件，并加载到文件中
2）执行该类的静态代码块，如果有的话，给Person.class类进行初始化
3）在堆内存中开辟空间，分配内存地址
4）在堆内存中建立对象的特有属性并进行默认初始化
5）对属性进行显示初始化
6）对对象进行构造代码快初始化
7）对对象进行与之对应的构造函数初始化
8）将内存地址赋给栈内存中的p变量


3：实例变量和类变量的区别
1）存放位置：类变量随着类的加载而存在于方法区中
             实例变量随着对象的建立而存在于堆内存中
2）生命周期：类变量生命周期最长，随着类的消失而消失
             实例变量生命周期随着对象的消失而消失


4：单例设计模式
设计模式是解决某一类问题最行之有效的方法，Java有23中设计模式
单例设计模式是用于解决一个类在内存中只能存在一个对象的设计模式


想要保证对象的唯一：
1）为了避免其他程序过多的建立该类的对象，先禁止其他程序建立该类对象，即把构造函数私有
2）改为了让其他程序访问到该类的对象，只好在本类中自定义一个对象
3）为了方便其他程序对自定义的对象进行访问，可以对外提供一些访问方法


代码实现：
1）私有化构造函数
2）在类中建立一个本类对象
3）提供一个方法可以获取到该类对象




两种方式：饿汉式，懒汉式
饿汉式：先初始化对象
class Single
{
private static Single s=new Single();
private Single()
{}
public static Single getInstance()
{
return s;
}
}


懒汉式：既然懒，就是后面才初始化对象，即对象的延迟加载
        类进内场的时候，对象还没存在，只有调用了get方法时，才建立对象
class Single
{
private static Single s=null;
private Single();
public static Single getInstance()
{
if(s==null)
s=new Single();
return s;
}
}

1：继承
提高了代码的复用性
让类于类之间产生了关系，有个这个关系，才有了多态的特性


但是，千万不要为了获取其他类的功能，简化代码而去继承
必须是类与类之间有所属关系才可以继承，即他们之间的关系是 is a 


Java中，只支持单继承，不支持多继承（哪次讲枚举的时候，咋又说有多继承呢？）
因为多继承容易带来安全隐患：即当多个父类中定义了相同功能，但是功能内容不同时，子类对象不确定运行哪一个
但是Java保留了这种机制，并以另外一种形式来完成：多实现


Java支持多层继承，即继承一个体系


如何使用一个继承体系呢？
想要使用体系，需要先查阅父类的描述，因为父类中定义的是该体系的共性内容
通过了解共性功能，就可以知道该体系的基本功能


子父类出现后，类成员的特点
1）变量：如果子父类中出现非私有的同名成员变量，子类要访问本类中的变量，用this
      子类要访问父类中的变量，用super
super和this的使用几乎一致 
只是super代表的是父类对象的引用，this代表的是本类对象的引用
2）函数：当子类出现和父类一样的函数时，子类对象调用该函数，会运行子类函数的内容
         这就是继承的另外一个特性，重写
重写：当子类继承了父类，沿袭父类的功能到子类中。
      虽然子类具备该功能，但是功能的内容和父类却不一样
      这时，没有必要定义新的函数，而是使用重写，保留父类功能的定义，重写功能的内容
      重写时，子类的权限必须大于等于父类，否则会编译失败
      静态只能覆盖静态


3）构造函数
在对子类对象进行初始化时，父类的构造函数也会运行
因为子类的构造函数第一行默认会添加一条隐士的super()
super():会访问父类中的空参构造函数，而且子类中所有的构造函数的默认第一行都是super()
        如果父类中没有空参的构造函数，就必须制定访问哪一个构造函数


为什么子类一定要访问父类的构造函数：
因为父类中的数据子类可以直接获取，所以子类对象在建立时，要先看父类是如何对这些数据进行初始化的
所以子类在对象初始化时，要先访问以下父类中的构造函数
如果要访问父类中指定的构造函数，可以手动


结论：
子类的所有构造函数，默认都会访问父类中的空参构造函数
因为子类每一个构造函数内的第一行都有一句隐式的super()


当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句的形式来指定要访问的父类中的构造函数


当然，子类中的构造函数第一行也可以手动指定this语句来访问本类中的构造函数
子类至少会有一个构造函数会访问父类中的构造函数




4：final
1）可以修饰类，函数，变量
2）被final修饰的类不可以被继承，为了避免被继承，被子类复写功能
3）被final修饰的方法不可以被复写
4）被final修饰的变量是一个常量，只能赋值一次。
   当在描述事物时，一些数据的出现值是固定的，为了增强阅读星，就给这些值起个名字
   当这个值不需要改变时，就加final，作为常量。变量名全大写
5）内部类定义在类中的局部变量位置上，只能访问该局部被final修饰的局部变量


5：抽象
1）抽象方法一定存在于抽象类中
2）抽象方法和抽象类都必须被abstract修饰
3）抽象类中的方法要被使用，必须由子类复写全部的抽象方法之后，建立子类对象调用
   如果子类只覆盖了部分的抽象方法，那么子类还是一个抽象类
*抽象和一般类没有太大的不同
 该怎么描述事物就怎么描述事物，只不过该事物中出现了一些看不懂的东西
 这些不确定的部分，就是该事物的功能，需要明确出现，但是无法定义主体
 就通过抽象来表示


抽象类不可以被实例化
如果抽象类中没有抽象方法，那么它的目的仅仅是为了不让该类建立对象


6：接口：初期的定义就是一个抽象类。
         即当抽象类中的方法都是抽象的，就把该类中接口的形式表示
         interface
格式特点：
1）接口中常见定义：常量，抽象方法
2）常量;public static final 
   方法：public abstract
   即接口中的成员都是public
*接口不可以被创建对象，因为有抽象方法
 它需要被子类实现，子类对接口中的方法全部覆盖之后，子类才可以被实例化
 接口可以被多实现，即对不支持多继承的转换形式