JAVA学习笔记，从类和对象开始。

1.对象和类。

对象的内存分配。

 类里的属性（成员变量），定义再class大括号内的。在堆中。

局部变量，将声明在方法内，方法形参，代码块内，构造器形参，构造器内。局部变量必须要有赋值。要在内部提前给它写好。在内存的栈中。

public的方法，一个包下的，别的类中，声明要调用类的对象，可以调用。

static为线程共享，在类加载阶段就实例化，位于方法区。

2.方法。方法A中又调用了方法A，称之为递归方法。不能在一个方法里面定义另一个方法。 

 对象数组，类似于二维数组，stus【1】里装的是指针，用·调用变量。

3.匿名对象：new phone（）.sendEmail()

new phone（）.setprice=1000；

。就是不给变量名。所以这两个操作是完全独立的，谁也影响不到谁。只有实例里才能有值的改变。

 4.方法的重载：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同。重载要求只是参数个数和类型。方法内的东西可以重写。

4.1可变个数的形参。例如public void show（String ...strs）,中间三个省略号，但是这个必须声明在末尾。当调用可变个数形参的方法时，传入的参数个数可以是：0.1.2

这两个方法不能共存，第二个方法的传参  类.show ( new String[]{"a"} );如此传递数组的值。

但第一个方法的传参可以直接类.show ( “aa”，“bb”）；

4.2形参和实参。

 

 这种排序中这样改是错误的。

当参数是引用类型的数据时候，怎么交换。

 传进来的是一个地址的值，然后在堆空间里交换了值，所以这次能够交换成功。方法内的地址和方法外的地址一样。

 这种方式换值是正确的。

5.封装。为什么要封装，因为方便给我们定义的属性变量进行制约。

public void setIspay(Boolean isPay) {

this.isPay = isPay;

}这个是正常的。

public void setIspay(Boolean pay) {ispay = pay;}

为什么用this，是因为第一个成员变量和局部变量重名，加了this之后，就能分清。this可以理解为当前对象。

      

 修饰类的只能有两种，public和default。JAVA用4种权限修饰符来，来体现类和类的内部结构在调用时候的可见性不同。

get set 方法是public。

 在另一个类种，如此操作。调用set Age将12的值赋进去。

5.1构造器

例如Person p=new Person（）；相当于一个构造器

执行到17行代码的时候，正好用上下面定义的构造器，然后输出。。。。

                      

 一个构造器的作用，在定义对象时候赋值，即初始化对象的属性。

构造器也可以重载，用来接受不同类型的值，弄给对象。但加了传参的构造器之后就必须得传参。

一个类种至少有一个构造器，至少是系统默认给的。

开发工具，在一个类的source种找到产生generate，有构造器，也有getset方法。

总结：用构造器来创建对象，用getset方法来对属性操作。

 在一个构造器里调用另一个构造器，就执行了这个构造器里所有的代码，可以少写很多。

this（）结束后，写点自己特别的。

如果一共有n个构造器，则构造器种最多有n-1个，this（形参）。一个构造器内，this调用了一个后，不能再调用另一个，但他调用的那个可以调用了别的。

 6.import，使用的类或者接口是非java.lang包下定义的，则可以省略import结构。

 如果用的是不同包下两个同名的构造器，则第二个必须得这么写。

 就比如这个data，可能在util下有一个，那么当我们还想用java.sql.下的时候，就必须这样做。

就比如Field ，是lang包的子包，前面说了，lang包的不用导，但用包的子包却需要再导。

如果导入了lang包下的system.*,则输出语句可以直接写成out.println("hello")

import static:导入指定类或接口种的静态结构。

 这种import static 的落脚点一定是类种的结构，而不是类。一般import的落脚点是类。

导入包后，方法就可以直接用。

7.继承

 建一个student类的，里面覆盖person类的属性和方法。但保留自己的方法，减少了代码的冗余。

能继承到private定义的属性，方法。子类继承了父类所有的属性和方法。

一个子类只能有一个父亲。鼠标放在这个类上，ctrl +T，可以看它的继承情况。

所有的类，都直接或者间接继承 java.lang.object类。

8.run 的下面有个，debug as

 后面两个是 step over和，一步步往下执行，看看程序种变量发生的变化。

 step into进入方法。

后面有一个step return，如果进入方法，这个操作，可以跳出这个方法。

按rusume按钮，如果还有断电，执行到下一个断点出，没有，就终止。

写一个断点就是写一个system out输出。

一个按钮drop to frame，返回方法内的首行。

解决一个debug问题。step into失灵，无法进入方法。去debug as configurations，里点开右边界面的jre，给jre那里的选项改成JDK。alter一下即可。

9.方法的重写：在子类种可以根据需要对从父类种，继承来的方法进行改造。

要求

1：子类重写的方法必须和父类被重写的方法具有相同的方法名称，参数列表。

2.子类重写的方法的返回值类型，不能大于父类方法种返回值类型。

3.子类重写的方法的访问权限不能小于父类方法的访问权限。不能重写父类种private声明的方法。

4.子类方法抛出的异常不能大于父类被重写方法的异常。

子类重写父类的方法必须同时是非static或者static类，因为static类属于类，子类方法无法覆盖父类的。

一般写的时候会报错。类的重写不能在main方法里。如此，子类可以用自己的方法，如果调用了父类的方法，就声明一个父类的对象，来调用它的方法。

11.protected修饰符，同一个包下的类都可以用，不同包的子类继承父类的protected也可以用。可以跨包。不同包类不可以调用非public和private声明的。

super可以调用父类的，属性，方法，构造器。但不能在mian方法里用super。

想用不同包种父类的属性，还是得protected定义，只靠super是不行的。

super调用构造器的问题：调的也是父类的构造器。当重写子类的构造器的时候，前面的属性都被封装了，这里用不了this

 这样super了之后，就能在下面声明对象的时候赋值了。这样的super（参数类型）是调用了父类的构造器给自己用了。

当super和this同时带有参数时，一个构造器种只能有super（类型）或this（类型）。

而且super要声明在构造器的首行。

 

 tostring 方法如果不重写，输出结果只能返回 变量的名字和地址。

Student类继承person类时

 建一个空参构造器，这个构造器默认继承person类种的空参构造器。比如person类中的空参构造器里有一句输出，那么在Student类中

执行到这句话的时候就会输出。因为它省略了一句super.();没写，但是也存在。

12.子类对象实例化进程，子类在建的时候，在堆空间中，堆空间中就会加载所有父类声明的属性。一句话，是构造器创建的对象。一层一层的套娃（父类的父类），直到调用java.lang.Object.中空参的构造器为止，加载过所有父类的结构，子类才能考虑进行调用。

虽然创建子类对象时，调用了父类的构造器，但是只创建过一个对象。

所以子类在建立一个对象的时候，会用到父类的构造器。

13.面向对象的多态性。

父类person，子类man，父类的引用指向子类的对象。

 p2调用子类重写父类的方法。但不能调用person里没有声明过的方法（即子类特有的方法）。实际是编译的时候就没编译

编译态：指编译的时候编译eat这句话

执行态：指执行的时候实际执行的是person里重写的方法。

多态的使用，虚拟方法调用：我们在编译期只能调用父类中声明的方法，但在执行期我们实际执行的是子类重写父类的方法。

                       

 可以让下面整个func执行狗类特有的方法。这里利用多态性，不用再new 一个animal类。

就比如equals（object obj），一般属性里放的都是子类对象。就是想用人家子类重写的方法。对象的多态性，只适用于方法，不适合于属性。左编译右运行。

也称之为调用父类的虚拟方法。

多态是运行时行为。因为编译器是无法确定的。晚绑定

而重载，在编译的时候就已经被编译器给绑定了。

      有了对象的多态性以后，内存中实际是加载了子类中特有的属性和方法，但变量声明为父类类型。

编译时只能调用父类中声明的属性和方法。那如何才能调用子类中特有的属性和方法。

                        

 找一个M1，强制类型转换了属于是。这样节省内存，比新new一个对象要好。但这种类型转换一定要满足子父类的上下级关系，将父类引用强转为子类才是正确的。

14.

先判断是不是子父类关系，再强转。如果不是子父类的关系还要硬转，就会出现ClassCast异常。

目的还是为了调用子类中重写的方法。只有在多态的情况下才能强转型。

                                  

 15.object类只声明了一个空参构造器。

 此时对象的实体就是垃圾对象，等待被回收，但时间不确定。用system.gc()这句话来通知finalize，类的对象会调用object类中中的finalize方法。

final，finally，finalize的区别？

 object类中定义的equals（）和==的作用是相同的，比较两个引用的地址是不是相同的。

像String， Date，File，包装类等都重写了object类中的equals（）方法，重写后比较的不是两个引用的地址是否相同，而是比较的是两个对象实体的内容是否相同。

16.再度回首运算符。

          

 mian里不能用这两个属性，除非变成了static类，或者直接在main里赋值。或者new调用对象赋值。

                   

一些关于==的判断结果

                     

                    

 这里已经重写equal方法了，可以通过两个属性的值，进行匹配。

用this进行匹配。

17.当object类中toString没有被重写的时候，返回对象的类型和地址。

 普通的输出对象，不用toString，例如System.out.println("new"+my);在这个连接操作里，

实际上已经调用了哦、Object类里的toString。

 这个图里能输出MM。是因为String 类已经重写了toString 方法。

像String Date File 包装类等都重写了object中的toString方法。

18.包装类。基本数据类型不能点，也不能整对象，没点面向对象的样，所以就有了包装类。

前几个数值型的类，都是继承于number。

就int和char的变成了Integer和Charcter，别的都是首字母大写。

 转成对象，可以传入别的参数类型是对象的方法。

 如何写一个测试，只测方法的输出。

             

 第二个，输出的结果是123.

包装类转化成基本数据类型。

 对象，类型value，将包装类对象转化为基本数据类型。

19.

        JDK 5.0的特性，自动装箱拆箱 （在基本数据类型和包装类之间的转换）      

            

在此基础上，可以将包装类和基本数据类型统一了，现在要研究

String 类型和这个大的统一之间的转换。

方式1：String str=num1+" ",用连接操作。

方式2：调用String 里的重载方法valueof：float f1=12.3f;

                                                                String.valueof(f1);

强转操作：int num1=（int）str；X

  Inreger i1=（Integer）Str；X这俩都是错的

因为强转类型只能是     有子父类的关系。那么如何String如何转为包装类的？

调用包装类中的parse方法，int num1=Integer.parseInt(str1);可以通过编译

                   

 三元运算符，将里面的数据类型都提升到最高，所以输出结果为1.0，在编译的阶段。

                          

  第一个是new的对象，比的肯定是地址。

第二个，自动装箱了，但也只是装在类的属性里，和但跟new的对象有点差距，仍然相等。

第三个就是纯纯的越界了，integer内部定义了Integer cach保存了-128到127的整数，如果我们使用了，如果我们使用自动装箱的方式，必须在这个范围内才是true。

20.引用：数组，接口，类。

 数组可以看作一个特殊的类了，是object的子类，所以能传。getclass是获得当前类名的方法，getSuperclass是获得父类名的方法。

21。tostring和普通的输出还是有区别的，第二个用toString的出现空指针异常。

第一个是因为

print方法里，如果引用是null，避免空指针，会输出null。

.

22.Static关键字的使用。static关键字单独在一个空间里，如果static定义的变量nation在对象1中被修改成6，则输出对象2中的nation时候，不用赋值，已经成了6，可以直接输出。

   一 1.静态变量随着类的加载而加载。

     2.静态变量早于对象的创建。用构造器创建对象的时候已经在加载静态变量了。所以可以直接使用类.属性的方式调用静态变量。对象本来就可以调用静态变量。

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

     4.如何判断一个属性是否声明成static？如何判断一个方法是否声明成static？

     就比如说，每个账户的账号，密码，余额不同。但利率和最小余额大家都是一样的。

     利率和最小余额就可以作为静态变量。

    总结：不会随着对象不同而不同的变量。

二：静态方法。

   1.也是随着类的加载而加载。

   2.静态方法中只能调用静态方法和属性（因为他们的声明周期不同步）。非静态方法既可以调用也可以。

    3.在静态的方法中不能使用this 。super关键字。因为是静态的可以直接输出。省略的是类.

    4.操作静态属性的方法通常用静态。工具类中的方法习惯生成静态方法。没必要造对象了，直接类名.  调用方法。例如Math、Arrays、Collections

                             

类和对象的生命周期，不同步。晚出生的可以用早出生的，早出生的不能用晚出生的。

                         

23.单例设计模式

 也就是某个类只能有一个对象实例，那么这个类中的构造器就得私有化，并且只能在类的内部。用静态方法返回类内部创建对象。可以产生一个单例永久驻留在内存中，想用的时候就拿来用。

                            这个叫饿汉式，一开始就把对象造好，导致对象加载时间过长。线程安全。

                       

                      

   这里这个是错的，因为你调用一次方法就要创一个对象。

所以应该改成，也叫懒汉式，延迟了对象的建立，是线程不安全的，因为进入判断的时候会阻塞一下，导致多线程弄了两个对象，上来变成null，不用就不着急指定。

                      

        

 数据库是单例建一个池子，只有一个池子，里面放着对于用户的连接。用static加载池子，只加载一次，只建立了一个池子。

34.main方法。输出的时候会弹出框，问你哪个作为出口。就当成普通股静态方法看待也行。静态方法里只能调静态的，不能调非静态。作为出口，用public修饰，在虚拟机中执行，权限不大，类.方法调不出来。

                       

  

35.main方法中可以作为我们和控制台交互方式（类似于Scanner）

                   

 方式1：跑一下，Java application,编译一下，然后run configuration里找到这个类，右边的Arguments，在框里输的值，就是传进方法的参数。

       

 

 如果加了这句话，就输出不了，框里的值。

 因为控制台传进来的数已经给args分配空间接受了，你又new一个，args又指向另一个空间。

方式2：cmd命令行的执行。

 刚开始加载不了主类，是因为还没有去掉包名。然后在 java 类 后一个空格那输入要传进去的参数。

36.代码块：就是类中一个大括号下面一块代码。

to String方法，目前只能输出这个类里的非静态属性。

      1.作用：用来初始化类，对象

   如果修饰，只能用static修饰    分为静态代码块和非静态代码块。

       2.静态代码块的执行：随着类的加载而执行。而方法是用类调用才能执行。

    非静态代码块的执行，随着对象的创建而执行。

 

    

 代码块的执行，谁先谁后，看位置。静态的先于非静态的执行。

 在静态代码块中只能调用静态结构，因为生命周期的原因。

非静态的则都可以调用静态或非静态的属性和方法。

静态代码块比静态构造器先运行。构造器要造对象的时候用，比类的加载晚一步。

在类的属性里可以直接int age=5；

但不能分步操作；

如果有静态又继承，调用构造器的时候一层层套娃，省略的super.() 执行父类的构造器，最终到object类中，执行静态的方向是从父类一级一级到子类加载，同时也加载静态的方法和属性。代码块的执行要先于构造器。

在方法体里，语句的执行是按顺序的。在类中没有顺序。可以先赋值再定义。

类里，非静态代码块中赋值和普通的赋值，看先后顺序，谁在上面谁先赋值。