Java备忘录//1-11

day1-cmd命令符-基本数据类型

1.常用的DOS命令
* a: 打开Dos控制台
* win+r–cmd–回车
* b: 常用dos命令
* cd.. : 退回到上一级目录
* cd\ : 退回到根目录
* cd tools: 进入tools文件夹
* d: : 回车 盘符切换
* cd d:\234 :进入d盘的234文件夹,再切换盘符(d:)才能进入d:\234
* dir : 列出当前目录下的文件以及文件夹
* cls : 清除屏幕
* ipconfig: 查看本机的相关网络配置
* c: dos控制台运行记事本程序
* D:>C:\windows\notepad.exe
* 还可以省略“.exe”后缀，例如：D:>C:\windows\notepad

2.标识符中常见的命名规则(这些规定是不受语法约束的)
* a: 包名：多单词组成时所有字母均小写，使用.连接 aaa.bbb.ccc
* b: 类名&接口名：大驼峰式 AaaBbbCcc
* c: 变量名&方法名：小驼峰式 aaaBbbCcc
* d: 常量名：多单词组成是所有字母均大写，使用_连接AAA_BBB_CCC

3.基本数据类型是Java语言中内置的类型，分别是
整数类型、小数类型、字符类型、布尔类型。
这四类基本类型是最简单、最基础的类型。
* 整数(byte、short、int、long)、小数(float、double)、字符类型(char)、布尔类型(boolean)
* 引用数据类型(String): 是强大的数据类型，它是基于基本数据类型创建的。

day2-逻辑运算符

1.逻辑运算符的使用

运算符   运算规则         范例           结果
&        与          false&true      False
|        或          false|true      True
^        异或         true^flase      True
!        非            !true         Flase
&&       短路与       false&&true     False
||       短路或       false||true     True

规律小结:
短路与&&:参与运算的两边数据，有false，则运算结果为false；
 短路或||:参与运算的两边数据，有true，则运算结果为true；
 逻辑非! : 参与运算的数据，原先是true则变成false，原先是false则变成true。

2.三元运算符
格式: (条件表达式)？表达式1：表达式2；
代码案例
方式一：System.out.println( 3>2 ? “正确” : “错误” );
// 三元运算符运算后的结果为true，运算结果为表达式1的值“正确”，然后将结果“正确”，在控制台输出打印
方式二：
int a = 3;
int b = 4;
String result = (a==b) ? “相等” : “不相等”;
//三元运算符运算后的结果为false，运算结果为表达式2的值“不相等”，然后将结果赋值给了变量result
方式三：
int n = (3>2 && 4>6) ? 100 : 200;
//三元运算符运算后的结果为false，运算结果为表达式2的值200,然后将结果200赋值给了变量n

3.运算符

运算符 运算规则    范例              结果
/       除       5/2                 2
%       取模      5/2                 1
++      自增      int a=1;a++/++a     2
--      自减      int b=3;a--/--a     2

• B: 注意事项
  *a:加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。
  *b:除法“/”当两边为整数时，取整数部分，舍余数。当其中一边为浮点型时，按正常规则相除。
  *c:“%”为整除取余符号，小数取余没有意义。结果符号与被取余符号相同。
  *d:整数做被除数，0不能做除数，否则报错。
  *e:小数做被除数，整除0结果为Infinity，对0取模结果为NaN

4.算数运算符++、–的使用
* a: ++运算符，会在原有值的基础上自增1
* b: –运算符，会在原有值的基础上自减1。
* B:++ – 位置的使用
* a:++,–运算符后置时，先使用变量a原有值参与运算操作，运算操作完成后，变量a的值自增1或者自减1；
* b:++，–运算符前置时，先将变量a的值自增1或者自减1，然后使用更新后的新值参与运算操作。

5.赋值运算符的使用

    运算符 运算规则    范例      结果
    =       赋值      int a=2     2
    +=      加后赋值    int a=2，a+=2    4
    -=      减后赋值    int a=2，a-=2    0
    *=      乘后赋值    int a=2，a*=2    4
    /=      整除后赋值   int a=2，a/=2    1
    %=      取模后赋值   int a=2，a%=2    0

//上面的运算符作用：将等号左右两边计算，会将结果自动强转成等号左边的数据类型,再赋值给等号左边的
//注意：赋值运算符左边必须是变量

public class OperatorDemo2 {
    public static void main(String[] args) {
        byte x = 10;
        x += 20;// 相当于 x = (byte)(x+20);
        System.out.println(x);
    }
}

day5-方法重载

1.方法重载
Java允许在一个类中定义多个名称相同的方法，但是参数的类型或个数必须不同，这就是方法的重载。
方法的重载与返回值类型无关，它只有两个条件，一是方法名相同，二是参数个数或参数类型不相同。

重载方法参数必须不同：
参数个数不同，如method(int x)与method(int x,int y)不同
参数类型不同，如method(int x)与method(double x)不同g
参数顺序不同，如method(int x,double y)与method(double x,int y)不同
重载只与方法名与参数类型相关与返回值无关
如void method(int x)与int method(int y)不是方法重载，不能同时存在
重载与具体的变量标识符无关
如method(int x)与method(int y)不是方法重载，不能同时存在

2.参数
定义方法时，参数列表中的变量，我们称为形式参数
调用方法时，传入给方法的数值，我们称为实际参数

day6-ArrayList< T>

可以把ArrayList集合看作一个长度可变的数组

ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
//<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；

arraylist常用方法

boolean add（Object obj）//将指定元素obj追加到集合的末尾

Object get（int index）//返回集合中指定位置上的元素

int size（）//返回集合中的元素个数

//将指定元素obj插入到集合中指定的位置
boolean add（int index, Object obj）

//从集合中删除指定index处的元素，返回该元素
Object remve（int index） 

void clear（int index）//清空集合中所有元素

//用指定元素obj替代集合中指定位置上的元素
Object set（int index, Object obj）

day9-this的讲解

this的作用：
为了避免就近原则（本来会优先使用局部变量，this后就变成了成员变量），
用来区别同名的成员变量与局部变量（this.成员变量）

//eg.1
public void setName(String name) {
    this.name = name;
}
//eg.2
class Person {
    private int age;
    private String name;

    public void speak() {
        this.name = "小强";
        this.age = 18;
        System.out.println("name=" + this.name + ",age=" + this.age);
    }
}

day10-继承-重载-抽象

继承：是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有的类

继承的好处：
可继承的属性和方法。
提高了代表的可维护性
提高了代码的复用性
让类与类之间产生了继承关系

继承的弊端：
类与类之间的耦合度过高

继承特点：
java中类只能够单继承，不能多继承，可以多层继承

class Yy extends Object {}
class Fu extends Yy{}
class Zi extends Fu {}
//所有的类都直接或者间接的继承了 Object类，Object类称为祖宗类

继承的注意事项：
1，使用关键字 extends 让类与类之间 产生继承关系
2, 父类私有的成员，子类不能继承，因为根本看不到
3，不能为了继承某个功能而随意进行继承操作， 必须要符合 is a 的关系

苹果 is a 水果
男人 is a 人
狗   is a 人  // 这种情况就不能继承了

继承中的成员变量关系：
不同名的变量：子类直接继承使用
同名的变量：默认访问的是子类自己的成员变量, 想访问父类中的同名变量，请使用 super.成员变量;

继承中的成员方法关系：
不同名的方法：
子类直接继承使用
同名的方法：
默认访问的是子类自己的成员方法，想访问父类中的同名方法，请使用 super.成员方法();

super:用来表示当前对象中包含的父类对象空间的引用
调用父类的成员变量：super.成员变量;
调用方法的成员方法:super.成员方法();

方法重写(override)：指 在子父类中，出现了方法声明相同的情况，也叫做方法覆盖，方法复写
方法重写的注意事项：
1，子类的方法声明要与父类相同
2, 子类要重写方法的方法，方法的权限修饰符不能比父类的更低
3, 父类私有的方法，子类不能够进行方法重写

方法重载(overload)：指 在同一个类中，多个方法名称相同，它们的参数列表不同(个数不同，数据类型不同)

抽象
抽象方法： 方法只有声明部分，没有方法体
抽象类： 包含抽象方法的类，一定是抽象类
使用 abstract 修饰的类，是抽象类

抽象类的特点：
1，抽象类与抽象方法都必须使用 abstract来修饰，抽象方法一定要定义在抽象类中。
2，抽象类不可以直接创建对象，原因：调用抽象方法没有意义。
3，抽象类中可以有抽象方法，也可以没有抽象方法
4，抽象类的子类
a，实现了抽象方法的具体类
b，抽象类
5，只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类。
之所以继承抽象类，更多的是在思想，是面对共性类型操作会更简单。

抽象类面试题：
抽象类中是否可以没有抽象方法？如果可以，那么，该类还定义成抽象类有意义吗？为什么？
可以没有抽象方法，有意义，不会让其他人直接创建该类对象，如果有抽象方法，那就是为了提示别人（研发组里另外的成员）里面的抽象方法必须重写，否则会出错。举个例子，人、男人和女人都会吃饭、睡觉，那这两个就可以抽取出来作为抽象方法，因为这是共性，如果一个人不会上面两个方法是活不下去的。
整个继承体系,越向上越抽象,越向下越具体

子类的共性抽取形成父类
父类:具有所有子类的共性内容
子类:不但有共性还有自身特有的内容

重载与重写对比:

重载
简单说，就是函数或者方法有同样的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

重写
重写指的是在Java的子类与父类中有两个名称、参数列表都相同的方法的情况。由于他们具有相同的方法签名，所以子类中的新方法将覆盖父类中原有的方法。

---

重载:
权限修饰符(public private 默认):无关
方法名:重载的两个方法的方法名必须相同
形参列表:
1.形参类型的顺序不同
2.形参的个数不同
3.形参的类型不同
三者至少满足一个
返回值类型: 重载与返回值类型无关
——————————————
重写:
权限修饰符(public private 默认):
子类方法的权限>=父类的方法的权限
方法名: 子类方法和父类方法必须相同
形参列表: 子类方法和父类方法的形参列表必须相同
返回值类型:
基本类数据类型:必须相同
引用数据类型:子类方法的返回值类型和父类方法的返回值类型相同
或者
子类方法的返回值类型是父类方法的返回值类型的子类

day11-接口

接口和抽象的区别——-例：
犬：行为：
吼叫；
吃饭；

缉毒犬：
行为：
吼叫；
吃饭；
缉毒；

2、思考：
由于犬分为很多种类，他们吼叫和吃饭的方式不一样，在描述的时候不能具体化，也就是吼叫和吃饭的行为不能明确。当描述行为时，行为的具体动作不能明确，这时，可以将这个行为写为抽象行为，那么这个类也就是抽象类。
可是当缉毒犬有其他额外功能时，而这个功能并不在这个事物的体系中。这时可以让缉毒犬具备犬科自身特点的同时也有其他额外功能，可以将这个额外功能定义接口中。

interface 缉毒{
    public abstract void 缉毒();
}
//定义犬科的这个提醒的共性功能
abstract class 犬科{
public abstract void 吃饭();
public abstract void 吼叫();
}
// 缉毒犬属于犬科一种，让其继承犬科，获取的犬科的特性，
//由于缉毒犬具有缉毒功能，那么它只要实现缉毒接口即可，这样即保证缉毒犬具备犬科的特性，也拥有了缉毒的功能
class 缉毒犬 extends 犬科 implements 缉毒{

    public void 缉毒() {
    }
    void 吃饭() {
    }
    void 吼叫() {
    }
}
class 缉毒猪 implements 缉毒{
    public void 缉毒() {
    }
}

接口和抽象类的区别：
相同点:
都位于继承的顶端,用于被其他类实现或继承;
都不能直接实例化对象;
都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:
抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;
一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)
抽象类是这个事物中应该具备的你内容, 继承体系是一种 is..a关系
接口是这个事物中的额外内容,继承体系是一种 like..a关系

二者的选用:
优先选用接口,尽量少用抽象类;
需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

多态

多态体现为父类引用变量可以指向子类对象。
多态的前提是必须有子父类关系或者类实现接口关系，否则无法完成多态。
在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

多态的定义格式：就是父类的引用变量指向子类对象
父类类型 变量名 = new 子类类型();
变量名.方法名();

//普通类多态定义的格式
//父类 变量名 = new 子类();
class Fu {}
    class Zi extends Fu {}
    //类的多态使用
Fu f = new Zi();

//抽象类多态定义的格式
//抽象类 变量名 = new 抽象类子类();
abstract class Fu {
    public abstract void method();
}
class Zi extends Fu {
    public void method(){
        System.out.println(“重写父类抽象方法”);
    }
}
//类的多态使用
Fu fu= new Zi();

//接口多态定义的格式
//接口 变量名 = new 接口实现类();
interface Fu {
    public abstract void method();
}
class Zi implements Fu {
    public void method(){
        System.out.println(“重写接口抽象方法”);
    }
}
//接口的多态使用
Fu fu = new Zi();

注意事项
同一个父类的方法会被不同的子类重写。在调用方法时，调用的为各个子类重写后的方法。

Person p1 = new Student();
Person p2 = new Teacher();
p1.work(); //p1会调用Student类中重写的work方法
p2.work(); //p2会调用Teacher类中重写的work方法

当变量名指向不同的子类对象时，由于每个子类重写父类方法的内容不同，所以会调用不同的方法。

class Fu {
    int num = 4;
}
class Zi extends Fu {
    int num = 5;
}
class Demo {
    public static void main(String[] args)  {
        Fu f = new Zi();
        System.out.println(f.num);
        Zi z = new Zi();
        System.out.println(z.num);
    }
}

多态成员变量
当子父类中出现同名的成员变量时，多态调用该变量时：
编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。
运行时期：也是调用引用型变量所属的类中的成员变量。
简单记：编译和运行都参考等号的左边。(左边是说父类)

class Fu {
    int num = 4;
    void show() {
        System.out.println("Fu show num");
    }
}
class Zi extends Fu {
    int num = 5;
    void show() {
        System.out.println("Zi show num");
    }
}
class Demo {
    public static void main(String[] args)  {
        Fu f = new Zi();
        f.show();
    }
}

多态成员方法
编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。
运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。
简而言之：编译看左边，运行看右边。
子类方法会覆盖父类方法，优先使用子类方法。

---

instanceof关键字
我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型。如学生的对象属于学生类，学生的对象也属于人类。
使用格式：
boolean b = 对象 instanceof 数据类型;

Person p1 = new Student(); // 前提条件，学生类已经继承了人类
boolean flag = p1 instanceof Student; //flag结果为true
boolean flag2 = p2 instanceof Teacher; //flag结果为false

---

多态的转型分为向上转型与向下转型两种：
向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。
使用格式：
父类类型 变量名 = new 子类类型();
如：Person p = new Student();
向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的！
使用格式：
子类类型 变量名 = (子类类型) 父类类型的变量;
如:Student stu = (Student) p; //变量p 实际上指向Student对象

---

什么时候使用向上转型：
当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作，这时就可以使用向上转型。
如：Animal a = new Dog();
a.eat();
什么时候使用向下转型
当要使用子类特有功能时，就需要使用向下转型。
如：Dog d = (Dog) a; //向下转型
d.lookHome();//调用狗类的lookHome方法
向下转型的好处：可以使用子类特有功能。
弊端是：需要面对具体的子类对象；在向下转型时容易发生ClassCastException类型转换异常。在转换之前必须做类型判断。
如：if( !a instanceof Dog){…}

多态例子

//毕老师和毕姥爷的故事
/*
描述毕老师和毕姥爷，
毕老师拥有讲课和看电影功能
毕姥爷拥有讲课和钓鱼功能
*/
class 毕姥爷 {
    void 讲课() {
        System.out.println("政治");
    }

    void 钓鱼() {
        System.out.println("钓鱼");
    }
}

// 毕老师继承了毕姥爷，就有拥有了毕姥爷的讲课和钓鱼的功能，
// 但毕老师和毕姥爷的讲课内容不一样，因此毕老师要覆盖毕姥爷的讲课功能
class 毕老师 extends 毕姥爷 {
    void 讲课() {
        System.out.println("Java");
    }

    void 看电影() {
        System.out.println("看电影");
    }
}

public class Test {
    public static void main(String[] args) {
        // 多态形式
        毕姥爷 a = new 毕老师(); // 向上转型
        a.讲课(); // 这里表象是毕姥爷，其实真正讲课的仍然是毕老师，因此调用的也是毕老师的讲课功能
        a.钓鱼(); // 这里表象是毕姥爷，但对象其实是毕老师，而毕老师继承了毕姥爷，即毕老师也具有钓鱼功能

        // 当要调用毕老师特有的看电影功能时，就必须进行类型转换
        毕老师 b = (毕老师) a; // 向下转型
        b.看电影();
    }
}

–总结–

封装、继承、多态的作用：
封装：把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式
继承：子类会自动拥有父类所有可继承的属性和方法。
多态：配合继承与方法重写提高了代码的复用性与扩展性；如果没有方法重写，则多态同样没有意义。

---

---

---

---

知识点总结
接口：理解为是一个特殊的抽象类，但它不是类，是一个接口
接口的特点：
1，定义一个接口用interface关键字
interface Inter{}
2，一个类实现一个接口，实现implements关键字
class Demo implements Inter{}
3, 接口不能直接创建对象
通过多态的方式，由子类来创建对象，接口多态
接口中的成员特点：
成员变量：
只能是final 修饰的常量
默认修饰符： public static final
构造方法：
无
成员方法：
只能是抽象方法
默认修饰符: public abstract
类与类，类与接口，接口与接口之间的关系
类与类之间：继承关系，单继承，可以是多层继承
类与接口之间: 实现关系，单实现，也可以多实现
接口与接口之间：继承关系，单继承，也可以是多继承
Java中的类可以继承一个父类的同时，实现多个接口

多态：理解为同一种物质的多种形态
多态使用的前提：
1，有继承或者实现关系
2，要方法重写
3，父类引用指向子类对象
多态的成员访问特点：
方法的运行看右边，其他都看左边
多态的好处：
提高了程序的扩展性
多态的弊端：
不能访问子类的特有功能

多态的分类
类的多态
abstract class Fu {
public abstract void method();
}
class Zi extends Fu {
public void method(){
System.out.println(“重写父类抽象方法”);
}
}
//类的多态使用
Fu fu= new Zi();

接口的多态
interface Fu {
public abstract void method();
}
class Zi implements Fu {
public void method(){
System.out.println(“重写接口抽象方法”);
}
}
//接口的多态使用
Fu fu = new Zi();

instanceof 关键字
格式： 对象名 instanceof 类名
返回值： true, false
作用： 判断指定的对象 是否为 给定类创建的对象