第二周总结

day10
1.构造方法名字与类名相同，不声明时系统默认为无参构造方法。它是一种特殊的方法。
2.方法名字可以相同但是方法签名不可以相同。方法签名为方法名字+形式参数类型列表，当调用者声明变量类型之后若要编译则系统会先寻找是否有该类型的方法，如果没有，它会寻找是否有可以强制转换类型而达到目的的方法如果还是没有则不会编译成功,要是有一个方法，两个类型都是int而另外有两个一个是int和String另一个是String和int则它会选择前者，因为他会先按照第一个类型去查找。像这种名字相同但是形参类型不同的方法就叫做方法重载，它的作用很明显，在很多意思相同但类型不同的方法上面不用为了区分为挨个去起名字，能让他们都达到见文知意的效果。
3.toString方法是默认调用的，他在输出的时候按照return后面给出的格式去输出方法为 public String toString(){
return 自己的形参以及想要的各种输出格式+;
}
4.对某个数值开根号写法为Math.sqrt(被开的数值)
day11
1.只有int input=sc.nextInt()定义时才加Int这也是int类型的意思，当input是String类型的时候后面是没有Int的。通常情况记住这两个格式就好，因为这个原因我今天在编译的时候出现了错误并且找了半天也没发现。
2.类名[ ] 数组名=new 类名[ ];是定义一个特殊数组的方法，之所以说是一个特殊的数组是因为它的每一个元素都是一个对象，和二维数组有点相似之处，里面不是单纯的int类型的数值，而是很多，在存储区当中实际上数组中存在的就是对象的地址。不过数组也在堆中。调用方法时操作为
数组名[第几个元素].方法名();
3。思考行列问题是不能按照寻常的xy逻辑去想，要考虑程序的先后顺序，因为程序先执行一行的然后再向下执行，所以定义时最好也是先定义行(row)再定义列(col);因为程序是给别人看的，除了要培养写备注的习惯之外还要尽可能地去用普遍想法来编写程序，省着耽误事。
4.jvm所拥有的内存空间源自电脑本身的内存空间。至于是那一块，是一块还是几块，都是随机的，而电脑上的内存空间在一个小电路板上。jvm大致分三个主大区域，方法区，堆和栈。方法区主要放程序运行时所需要的类，堆放的对象，栈就是形式参数。栈帧是一块临时的空间，用于局部变量的各项操作，当局部变量操作完区域消失。没有被形参所指向的对象会被当成垃圾，通过jvm的垃圾回收机制会被清除以防止内存被无故占用。
5.判断调用者输入的字符用input.equals(“a”)
6.面向对象的核心思想就是用类，对象，继承，封装，静态绑定，动态绑定等进行核心设计。
day12
父类{可以有构造器 成员变量 方法}
子类{继承自父类，也可以有自己的独有的成员变量和方法}
为了防止麻烦像this一样还要区别到底是谁的变量，所以要是有相同名字的成员变量尽量改改，不改也可以只是看着恶心罢了。
子类一定用发到了父类的构造器，不过父类要是无参构造器的话子类有可能隐式调用。因此如果父类没有无参构造器，子类一定要显示如何调用的
重写的概念
当父类型的变量引用子类的对象时，语法为：父类名 变量名=new 子类名();
此时若是子类当中的方法父类没有则不能编译，若想执行可以在父类里面定义一个空的类，编译就能成功，运行时它会自动去找真正指向的那个对象以及真正的方法。不过在编译器期间我认为想要找到父类的方法必须p.类名所以我认为必须先要有父类的实例化对象，可是后来老师说当p是空的时候虽然报错但是却也编译成功了，也就是说不一定非要创建父类对象，对此还需研究。按个人想法来吧。
day13
1.四个修饰词的方法及它们的使用范围
2.修改了保存之后的文件它的上面会有*标记，有的时候会因为没有保存而存在错误提示，要留心注意。
3.Object是所有引用类型的顶级父类，它自己里面有很多的方法，其中toString方法是将对象的地址输出，因此当我们要用到toString去输出想要的内容时需要重写toString。相同的equals也是它的一个方法，作用是比较两个两个对象是不是同一个代码为
public boolean equals(Object obj) {
return (this == obj);
}
两个等号符号意思是两个对象的地址进行比较，而在我们现实使用过程中，其实存在这种情况。两个不同对象有相同的内容，而这种也是我们所需要的，可是这个方法也会认为是错的，所以在比较之时就需要我们重写。代码如下
public boolean equals(Object obj){
if(obj==null){
return false;
}
if(obj==this){
return true;
}
if(!(obj instanceof Point)){
return false;
}
Point p1=(Point)obj;
return p1.x==this.x&&p1.y==this.y;

}
Point是该类，首先判断Object类型的obj是不是空的，然后判断是不是自己本身，再然后判断是不是Point的类型如果是的话在进行下面判断，Point p1=（Point）obj；指的是将当前的obj强制转换成Point类型，为什么已经是该类型还要转换呢，因为机器不知道它到底是不是，它只是按照程序一步一步走下去，而不像人一样分析出来，最后将各个元素进行对比都一样的话就是内容一样达到了预期效果

4.包是用于管理源文件，区分类全名。几个关键的有
java.lang.*,因为里面的类型非常常用，因此不需要导包 像Math
java.util.*,此包下封装了很多常用的工具类 像Arrays Scanner
java.io.*,此包下封装了io流的类型
java.net.*此包下封装很多关于网络的多种类型
当用到一个包里面的两个方法时可以直接用*去代替这样省着写俩
5.Shift+Alt+S快捷键可以自动生成很多类里面的常用方法非常好用，不过要理解每个方法具体逻辑，就像上面的equals一样。
day14
没啥写的了看看老师总结的
方法的重载(overload)与重写(override)

概念:
重载： 在同一个类中，方法名相同，参数列表不同
重写: 子类重写父类的方法，方法名相同，参数列表相同
返回值类型可以相同，也可以是父类方法的返回值类型的子类
修饰词可以相同，或者权限比父类方法的权限大
访问权限控制修饰词
修饰的成员变量和方法

                本类中     同一包下      子类     其他
public          true        true        true    true
protected       true        true        true
default         true        true
private         true   

final:
(1)修饰类：不能被继承，意义在 减少随意扩展功能的可能性，减少对系统的危害
(2)修饰变量:只能进行初始化，不能再被赋值
成员变量: 初始化的时机有两种
声明时同时初始化
在构造器中初始化
局部变量：使用前初始化即可

(3)修饰方法: 不能被重写，意义在于: 可以避免某些子类”不经意”的重写

static:英文含义：静态
1、修饰成员变量
(1)修饰的成员变量，不属于对象的数据结构
(2)静态变量属于类的，通常使用类名去调用
(3)静态变量与类的信息一起存在方法区中,只存在一份，是
对象的公共资源
2、修饰方法
(1)通常的方法都是与具体对象有关系，即对象的方法(行为)
(2)如果是static方法则与对象毫无关系，是类的方法，通常用类名去调用
常常与参数有关系
(3)static方法内因为无法使用this关键字，因此不能直接访问非静态成员
(4)static方法的作用一般都用于设计成”工具方法”和”工厂方法”

          如:   Arrays.sort(数组名);
       Math.random();
       Math.sqrt(参);
       Math.abs(参);
       Math.sin(参数);
    3、static修饰代码块
   static{
        代码逻辑
   }

         静态块存储在方法区中，只加载一次，与对象无关。
         执行时机为加载类的信息期间，可以理解为在实
         例化之前

作用:通常用于加载程序中所需要的静态资源:如：图片,音频，视频等

       非静态代码块与静态代码块，成员变量，方法都是
       类的成员
 {
 } 

      运行时机:在实例化之前执行，每次实例化之前都会执行一次      

常量：
一般都是一些特殊值。
一般都使用成员变量，修饰词为public static final
声明时必须初始化
命名规则: 字母全都大写

如: Math.PI

设计模式之单例模式
需求:在程序中的任何地方，我们想要获取某一个类的唯一对象。
我们称之为类的单例

 Singleton
 (1)提供一个私有的静态的本类型的成员变量
 (2)构造器私有化
 (3)提供公有的静态的方法获取本类中创建的实例。

 饿汉写法:  加载期间就实例化对象
 public class Singleton{
    private static Singleton instance = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return instance;
    }
 }
 懒汉写法:  调用方法时才创建对象
 public class Singleton{
    private static Singleton instance ;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance ==null){
            instance = new Singleton();
        }
        return instance;
    }

}

抽象类:
因为继承的关系，子类的功能可以越来越具体，相对来说，父类
更加一般化，通用化。因为父类封装了子类的共同行为，所以，
在定义时，我们可以定义方法的逻辑。有的时候，在父类中无法完成
子类的功能需求，此时，不如不写，即不写方法体，代码简单化。
但是此方法必须使用abstract修饰，那么此类型也必须使用abstract
修饰，即抽象类

1、抽象方法与抽象类
1)用abstract修饰的方法，不需要写方法体，但是得用分号来结尾
2)有抽象方法的类，必须使用abstract声明(修饰)
2、抽象类不能实例化
1) 抽象类不能创建对象，没有意义
2) 抽象类可以提供构造器
3) 抽象类中可以没有抽象方法
4) abstract和final不能同时修饰一个类型
3、继承抽象类
1)若一个类继承了抽象类，那么这个类必须重写(实现)抽象类的所有抽象方法
2)若一个类没有实现抽象类的所有抽象方法， 那么这个类必须使用abstract修饰
4、抽象类的意义：
1)给不同的子类定义一个父类
2)抽象类可以封装子类的共同特征与共同行为
3)虽然子类方法可能有不能的实现逻辑，但是
方法的定义一致。