javaSE（03）

面向对象

1.万物皆对象，面向对象编程（Object Oriented Programming）OOP
2.对象的特征：属性：姓名，性别，年龄等。。。对象的行为：方法：吃，喝，睡等。。。
3.存储对象信息：（1）哪里使用就在哪里定义。（2）打包在一起，重复利用。
4.类：类就是数据类型，也就是类别，计算机和程序是为人类和现实生活服务的，那么编程语言的主要作用就是用来描述现实生活中的事物，例如：计算机不知道什么是
整数，什么事字符，因此编程语言就创造出了数据类型告诉计算机10是整数，a是字符，这就是数据类型的作用，用来描述现实生活中的事物。世间万物都有类别，
这些事编程语言无法提供的，也就是说编程语言并不知道什么是书，车，这些需要自己定义出来。
5.类就是对象的数据类型，例如：普京的类型是总统，如花的类型是美女，1的类型是int。
6.类和对象的关系：类是图纸是模板，类是抽象的，对象是具体的，
7.java自定义类的格式（类的命名规则：1.不能使用关键字2.不能以数字开头3.推荐首字母大写4.可以使用汉字但不推荐5.和其他一样数字，字符，_和$）
class 类名{
//定义属性
属性1；
属性2；
…
属性n；

//定义方法
方法1；
方法2；
…
方法n;
}
8.创建和使用对象
（1）创建对象：类名 对象名 = new 类名（）；例如：Student stu1 = new Student（）；
（2）使用对象（属性和方法都属于对象）：通过“.”调用，例如：对象名.属性名 对象名.方法名；
（3）方法的调用：在类的内部和外部调用。
（4）不同类和方法之间的调用(1)在方法内先new一个对象，然后调用方法，（2）对象在外部new，通过传参进入方法，然后调用。
9.面向对象（封装，继承，多态）
10.成员变量和局部变量
（1）作用范围：成员变量：定义在类中，即属性，可以被类中的任意方法访问。
局部变量：只在他所属的局部大括号中有效，一般出现在某个方法中。
（2）存储情况：成员变量(非静态)：存储在堆内存中，随着对象的存在而存在。当对象变成垃圾被回收时，该对象中的成员变量会消失。
局部变量：存储在栈内存中，当方法被调用，或者语句被执行的时候，才存在。
当方法运行完毕，或者语句运行完毕时，局部会被自动释放，所以成员变量也称之为实例(对象)变量。
（3）初始化情况：成员变量：在堆内存中有默认初始化值。
局部变量：必须手动初始化后，才可以被使用。
11.三大特性之封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装好处：（1）隐藏类的实现细节（2）只能通过规定方法访问数据（3）方便修改实现（4）方便加入控制语句
12.如何实现封装：使用private修饰符使属性私有化，给属性提供共有的getter/setter方法（对属性的操作只有存和取）
13.private属性：（1）是一个访问修饰符（2）用于修饰类中的成员（变量和方法）（3）被私有化的成员只能在本类中有效访问（4）当成员私有化以后，提高了安全性，
这时可以对外提供共有的getter和setter方法间接对其访问。（5）好处是可以在方法中对成员变量的访问进行控制。
14.构造方法：构造方法是在创建对象时给属性赋值，例如：使用构造方法：Person p1 = new Person()；

15.带参的构造方法：通过无参构造方法创建出来的对象都一样，这显然不太合适，那么构造方法也是可以有参数，通过带参数的构造方法，可以灵活地为对象赋予初始值。
16.构造方法与普通方法的区别：（1）从功能上：构造方法是给对象初始化的，普通方法是为了实现某个功能。
（2）从执行上：构造方法是对象创建的时候被执行，自动调用。普通方法是什么时候调用设么时候执行。
（3）从语法上：构造方法不需要有返回值，包括void，方法名和类名相同，普通方法必须具备返回值。
17. 注意：如果我们在一个类中没有显式定义任何构造方法，那么系统会自动向该类中添加一个无参的构造方法，不作任何事情。
如果我们在一个类中至少定义了任意的一个构造方法，那么系统就不会自动向该类中添加一个无参的构造方法了。
18.构造方法和普通方法一样可以实现方法重载，无参构造方法和有参构造方法就是方法的重载。（方法名相同，参数不同）
19.一个标准的类中应该包含的内容：1.若干个私有化的属性 2.若干个无参和有参的构造方法 3.若干个getter/setter方法 4.功能方法
20.初始化对象属性的方式：（1）构造方法（2）setterfangf（3）类中给属性直接赋值（不建议使用）
21.this关键字：this关键字只能用于方法体内。当一个对象创建后，JVM就会给这个对象分配一个引用自身的指针，这个指针就是this。this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。简言之：哪个对象调用this所在的方法，this就代表哪个对象。this只能在类的非静态方法中使用，静态方法和静态代码块中不能出现this，this代表本对象。
22.this关键字的用处：（1）方法参数或者方法中的局部变量与成员变量(属性)同名的情况下，成员变量(属性)会被屏蔽，此时要访问成员变量(属性)则需要使用“this”关键 字。当然，在没有同名的情况下，可以直接用成员变量的名字，而不用this，用了也不为错。
（2）在方法中，可以使用this关键字引用成员方法 ，一般很少这样做，默认就有。
（3）如果我们想在一个构造方法中对另一个构造方法进行调用的时候,不能在其构造方法中直接类名(参数)这样调用,而是通过this调用另一个构造方法，用法是this(参数列表)，这个只能用在类的构造方法中，别的地方不能这么用。这个this语句只能放在构造方法的第一行？？
（4）this是指向对象本身的一个指针
（5）每个子类构造方法的第一条语句，都是隐含地调用super()，Java要保证先初始化父类。this()和super()不能同时出现在一个构造方法里面，因为this必然会调用其它的构造方法，其它的构造方法必然也会有super语句的存在，相当于调用了两次父类的构造方法，这是不允许的。this()必须放在第一行，否则就会隐含地调用super()。
23.对象创建的过程：当执行Person p = new Person(“如花” , 35); 时，到底在内存中做了什么?
（1）将Person.class文件加载进内存。
（2）p是对象句柄(变量名)，那么在栈内存中开辟一个变量空间p。
（3）在堆内存中给对象分配空间,并分配内存地址值
（4）属性进堆内存，并进行默认初始化。
（5）调用对应的构造方法进行对象初始化，对象初始化完毕。
（6）将对象内存地址赋值给p变量，让p变量指向该对象。
24.匿名对象
（1）没有名字的对象（简化形式有局限性）
（2）一般用于只需要调用一次方法的场景（传参）例如：new Car().run();
25.类的内部调用直接通过方法名进行调用，外部调用必须通过对象。
26.记着关于参数的传递传进去的一定是对象，让后对象调用属性和方法。

---

27.static关键字：是一个修饰符用于修饰成员变量和成员方法。特点：（1）可以通过类名直接调用，被static修饰的成员变量变成了类变量，方法变成了类方法，类变量和类方法可以被直接调用：类名.成员变量 类名.成员方法（2）随着类的加载而加载，说明他的生命周期最长，优先于对象存在（3）静态属性被类中的所有成员所共享。
28.static变量和非static变量区别：（1）生命周期：静态变量的生命周期最长，随着类的加载而产生，随着类的消失而消失，实例变量（非静态变量）的生命周期随着对象的创建而产生，消失而消失。 （2）所属不同：静态变量属于类，被类中的所有对象共享。（3）内存中的位置：静态变量随着类的加载而存在方法区中，实例变量随着对象的建立而存在于堆内存中。
29.内存中的方法区是各个线程所共享的内存区域，它用于存储已被虚拟机加载的类的信息，常量，静态变量等。
30.使用静态变量注意事项： （1）静态方法只能访问静态成员。
（2）非静态方法既可以访问静态成员也可以访问非静态成员。
（3）非静态方法中不可以定义静态变量（随着类的加载而加载，已经存在了，不可以再次定义）。
（4）局部变量可以定义在任何方法当中，就像你书写的那样，静态方法不能使用非静态的全局变量。
（5）静态方法中不可以使用this，super关键字。
（6）先总结一下：与static无关的内容：<1>当使用static修饰一个方法时，表明这个方法属于该类本身，即通过类就可以调用该方法，但如果该方法被定义成抽象方法，则将导致通过该类来调用该方法 时出现错误（调用了一个没有方法体的方法肯定会引起错误）。因此static和abstract不能同时修饰某个方法，即没有所谓的静态抽象方法；<2>abstract关键字修饰的方法必须被其子类重写才有意义，否则这个方法将永远不会有方法体，因此abstract方法不能定义为private访问权限，即private和abstract不能同时修饰方法
31.静态的利与弊：利：对于对象的共享数据提供单独的存储，节省空间，没有必要每一个对象都存储一份，可以直接被类名调用。
弊:声明周期过长，访问出现局限性（静态方法只能访问静态成员）静态常用语工具类
32.main方法：main方法作为一个特殊的方法，作为程序执行的入口，可以被JVM识别。main方法是静态的，所以可以被JVM直接调用，main不是java关键字，main方法在被JVM调用的时候可以传递参数，但是很少使用。
33.代码块：代码块就是被{}包括的部分，java中的代码块分为：（1）普通代码块：又称为局部代码块，存在于方法体中。
（2）构造代码块：又称为初始代码块，在使用new关键字new对象的时候执行，且先于构造方法执行。
（3）静态代码块：被static修饰的代码块，在类加载的时候执行，只执行一次，且先于main方法执行。
34.执行顺序为（先后）：静态代码块>main方法>构造代码块>构造方法>普通代码块（存在于方法体中）
35.再论对象的创建过程：Person p = new Person()（1）将Person.class文件加载进内存（2）在方法区为静态属性分配内存并进行默认初始化（3）执行静态代码块（4）p是对象(变量)，那么在栈内存中开辟一个变量空间p（5）在堆内存中给对象分配空间,并分配内存地址值（6）方法进方法区（7）非静态属性进堆内存，并进行默认初始化
（8）调用构造代码块（9）调用静态属性进堆内存，并进行默认初始化（10）将对象内存地址赋值给p变量，让p变量指向该对象
36.javadoc命令可以根据文档注释生成帮助文档
37.java常用API之Math类：数学类，为方便使用都被设计成了static类，常用的方法有：（1）abc(double|float|int|long num),得到num的绝对值（2）double floor(double a),最接近a但是不大于a的小数（3）double pow(double a, double b),得到a的b次幂（4）double random(),得到一个大于等于 0.0 且小于 1.0的随机小数（5）round (double|float a),得到对a进行四舍五入后的整数（6）double rint(double a),得到对a进行四舍五入后的小数
38.java常用API之Scanner类：扫描器，用来实现控制台输入，可以接受用户在控制台输入的数据，import java.util.Scanner;Scanner sc=new Scanner(System.in);常用的方法有：
nextInt()接收整数nextDouble()接受小数next()接收字符串nextLine()接收字符串
39.next()与nextLine()方法的区别：空格键、Tab键、Enter键默认为输入结束符，next（）方法一定要读取到有效字符后才结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，会自动将其去掉，只有在输入有效字符之后，next()方法才将其后输入的空格键、Tab键或Enter键等视为结束符。因此，通过next()方法无法接收带有空格的字符串，nextLint()方法的结束符只是Enter键，即nextLine()方法返回的是Enter键之前的所有字符。
40.java常用API之Random类：用来生成随机数，功能比Math.random() 更强大，可以随机生成int,long,double类型的数据。常用方法：nextDouble()得到一个大于等于 0.0 且小于 1.0的随机小数,nextInt()得到随机的一个int型数字，nextInt(int n): 得到一个大于等于0小于n的随机int数。

---

41.继承：将重复代码抽取到一个父类中，方便修改代码，减少代码量，编写父类，编写子类继承父类，java只支持单一继承（子类只能有一个父类），可以出现多层继承。
class Pat{//公共的属性和方法} class Dog extends Pat{//子类独有的属性和方法}
42.对继承的理解：（1）子类可以继承父类中使用public和protected修饰的属性和方法，无论子类和父类是否在同一个包中。
（2）子类可以继承父类中默认的修饰符修饰的属性和方法，但是子类和父类必须在同一个包中。
（3）子类无法继承父类中使用private修饰的属性和方法，但是可以通过继承父类的getter和setter方法访问到私有属性。
（4）子类无法继承父类的构造方法。（构造方法要求与类名相同）不能为了继承父类的属性不适用封装
43.创建子类对象时的内存模型，Dog s = new Dog();对于父类的私有属性，子类有使用权没有所有权。super指向的是父类空间。

44.继承中的方法：要么子类直接继承父类方法，原样使用，要么子类重写父类同名方法，方法重写又叫方法覆盖。
45.方法重写规则：子类必须和父类中被重写的方法名相同，参数相同（包括个数，类型，顺序），返回类型相同或者是子类，子类方法的访问修饰符权限不能小于父类被重写的方法的访问修饰符的权限。
46.没有继承就没有方法重写，
47.super关键字：（1）在子类中可以使用super关键字访问父类非私有成员，super代表子类对象里的父类内存空间。
（2）子类可以访问父类构造方法，Super(),被默认添加，super(参数表)，且必须是构造方法的第一条语句。
48.继承中的构造方法执行顺序：父类属性>父类构造方法>子类属性>子类构造方法，
49. 继承关系中构造方法的调用规则：（1）如果果子类的构造方法中没有通过super显式调用父类的有参构造方法，也没有通过this显式调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，写不写“super();”语句，效果是一样的。
（2）如果子类的构造方法中通过super显式调用父类的有参构造方法，那将执行父类相应构造方法，而不执行父类无参构造方法。
（3）特别注意的是，如果存在多层继承关系，在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。
50.执行顺序为先静态，再父类，再子类。this和super不能同时出现在子类构造方法中。
51.final关键字 ：类不希望被继承，方法不希望被重写，属性值不希望被修改。被final修饰的 常量变成了自定义常量要大写。
51.多态：为什么使用多态：增加代码的可扩展性。同一个引用类型（父类），使用不同的实例对象（子类）从而执行不同的操作。父类引用子类对象。
父类 对象名 = new 子类 ();Pet p1 = new Cat(); p1.eat();
52.实现多态的三个步骤：1.实现继承2.子类重写父类方法。3.使用父类类型引用所有的子类对象。
53.向上转型：Pet p = new Dog();//向上转型符合继承关系中的is-a关系。缺点：不能调用子类独有的成员。因此在“执行前”无法判断父类所引用对象的实际类型。
54.向下转型：Pet p = new Dog();Dog d = (Dog)p;//向下转型必须强转。因为不符合继承中的is-a 关系，但是可以调用子类中的独有方法。
55.多态细节：成员变量（非私有）在编译和运行时都看左边，成员方法（非私有）编译看左运行看右。

---

56.抽象类：抽象是把多个类中相似的、共性的内容抽取出来，继承就是如此，Pet p = new Pet();没有实际意义，父类是抽象出来的很多时候，父类只是一个模板，可以避免子类中的重复编码，new一个父类没有实际意义。abstract是实现抽象的关键字，可用于类抽象类不能实例化（不能new）。
57.抽象方法：父类中没有必要实现方法体，一般交给子类重写方法的时候实现，使用abstract可以实现抽象方法，抽象方法没有方法体，且只能出现在抽象类中，必须在子类中重写。抽象类中可以包含普通方法(即非抽象方法，例如getter/setter方法)，也可以没有抽象方法。父类一般都写成抽象类。
58.抽象类不能实例化，但是仍然可以有构造方法，自身不能new，子类可以调用父类的构造方法，abstract不可以和这些关键字共存：final：如果方法被抽象，就需要被重写，而final是不可以被重写，所以冲突，private：如果方法被私有了，子类无法继承，怎么重写呢？static：不需要对象，通过类名就可以调用抽象方法，而调用抽象方法没有意义。（因为没有方法体）
59.接口：接口就是一个特殊的抽象类，解决了java单一继承的问题，特征：（1）接口不能实例化（更加抽象的抽象类），不能有构造方法（抽象类可以有构造方法）
（2）接口中的所有属性都是public、static、final并且自动被实现类拥有。
（3）接口中的方法都是抽象方法（抽象类中可以有非抽象方法），接口中的方法不能有方法体，且自动使用public、abstract等修饰。
（4）一个类可以同时实现多个接口（多继承）
（5）实现类必须实现接口中的所有方法。
（6）接口可以继承接口，而且可以多继承（类不能多继承）使用接口：

60.类与接口之间的关系：类与类之间可以单继承、多层继承，类和接口之间可以多实现，接口和接口之间可以多继承，一个类可以继承一个类的同时实现接口。
61.如果类允许多继承，那么继承了不同的父类中相同的方法（但方法体不同）会出现安全隐患，如果换做接口（方法体没有实现）就没有安全隐患。

---

62.包名全部小写，不能以原点开头或者结尾，通常使用倒置的网络域名，公司域名.项目名。com.taobao.项目名.模块名，lang包不需要人工导入。
63.类的全称是：包名.类名，访问不在同一包中的类时，必须是public class。

1. 以后类前面加public，类中的属性都是private，方法都是public，父类一般用abstract，父类中功能性方法一般用abstract
   65.内部类：将一个类定义在另一个类的里面就是内部类，内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，内部类分为：成员内部类、静态内部类、局部内部类、匿名内部类，
   成员内部类：在外部类中，并且在方法外定义的，在外部类的方法中可以直接new内部类。在其他地方要访问内部类中的成员必须要建立内部类的对象。
   外部类 外部对象 = new 外部类(构造方法);
   外部类.内部类 内部对象 = 外部对象.new 内部类(构造方法);
   静态内部类：成员内部类加上static修饰符，静态内部类可以直接访问外部类中的静态成员，不能访问外部类的非静态成员了，这是其局限性，静态内部类是外部类中的成员,既然是静态修饰的,就可以直接用类名.调用。在外部类中访问静态内部类的情况有两种:（1）在外部类中访问静态内部类中的非静态成员：
   外部类.内部类 内部类对象 = new 外部类.内部类(构造方法);（2）在外部类中访问静态内部类中的静态成员：可以用上一种，也可以直接外部类名.内部类名.成员
   局部内部类：定义在方法中的类：局部内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。局部内部类的对象不能使用该内部类所在方法的非final局部变量，因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量全部死亡。但是该方法结束之后，在方法内创建的内部类对象可能仍然存在于堆中！而常量在类加载时就存在于方法区的“常量池”中，生命周期更长，只能访问外部类的静态成员。
   匿名内部类：没有名字的内部类，分为继承式的匿名内部类和接口式的匿名内部类，匿名内部类必须继承一个父类或实现一个接口，并且只能是一个。
   语法：new接口(){} 相当于实现这个接口，匿名实现 new父类(){} 相当于继承这个父类，匿名继承。匿名内部类通常用于参数，new一个对象，只用一次。
   匿名内部类不能有构造方法，不能定义任何静态成员和方法。