study1

1.什么是标识符？

程序员有权利自己命名的单词都为标识符。

可以标识 类名、方法名、变量名、常量名、接口名等。

2.标识符命名规则？

一个合法的标识符只能由数字、字母、下划线、美元符号组成。

数字不作为开头。

严格区分大小写

关键字不能作标识符。

理论上无长度限制，但最好别太长。

3.标识符命名规范？

最好见名知意。

遵守驼峰命名方式。如：SystemService、UserService

类名、接口名：首字母大写，后面每个单词首字母大写。

变量名、方法名：首字母小写，后面每个单词首字母大写。

常量名：全部大写。

全局变量（成员变量）：不初始化有默认值

局部变量：不初始化无默认值，所以局部变量在使用前必须先赋值，不赋值无法使用

全局变量和局部变量重名时，局部变量的优先级高于全局变量

基本数据类型作为形式参数，形参的改变不会影响实际参数，传递的是值的本身

引用数据类型作为参数，形参的改变影响实际参数，传递的是地址值（对象类型参数就是引用数据类型）

匿名对象的特点：对象只会被使用一次，作为调用者来说，之后就获取不到这个对象了。

如果对象只需要使用一次的话，那么我们就可以使用匿名对象。

匿名对象一旦使用完成就会自动释放，节约内存资源。

作为实际参数传递的时候会比较方便

在Java类中，类体以内及方法体以外，是无法编写逻辑代码的

private修饰的成员不能被外部直接访问。

虽然不能被外部访问，但是可以在本类中可以直接访问。

private的使用：

1.将不需要对外访问的属性加上此关键字，同时给出公有的get/set方法

2.将本类构造方法加上private关键字，拒绝外界直接创建对象

this关键字代表当前类的对象引用。

为什么要使用this关键字：

1.全局变量和局部变量重名

2.创建任意一个对象默认都会创建一个this的引用指向同一个堆区空间。

3.this的设计就类似于现实生活中的代词 我的

4.默认是同一个类的成员都会省略掉this关键字

5.谁调用就是谁，this表示当前对象的引用

6.this只能够出现在类的内部，静态方法无法使用this关键字，例如main方法

this的本质就是一个对象，引用，实例，变量，只不过和创建的对象指向了同一个块堆区的空间，使用this对堆的空间做了修改那么一样会修改对象本身

this应用场景：

1.当全局变量和局部变量重名的时候

2.当需要在类的内部访问本类的全局变量和全局方法

3.this访问本类的构造方法的时候

构造方法的作用：能够在对象创建之后对对象的全局变量快速的赋值。

构造方法的语法格式：

[访问权限修饰符] 类名 (参数列表)

{

方法体；

}

构造方法的特点：

1.构造方法没有返回值，连void关键字也没有

2.方法名必须和类名相同

3.方法体一般都是用来给全局变量赋值的

4.如果我们没有自己添加构造方法，系统会默认给我们提供一个无参的构造方法

5.如果我们自己添加了构造方法，那么会覆盖掉系统提供的默认的构造方法

6.构造方法可以重载（即只要参数不同就可以多次编写）

7.可以通过this关键字来实现构造方法之间的相互调用，但是用this进行构造方法调用只能出现在别的构造方法中的第一行，即只能调用一次且只能在某个构造方法中的第一行进行对别的构造方法的调用。如调用无参构造方法：this();

调用两个参数的构造方法：this(1，“zyf”);

...

8.在书写任何一个类的时候，都加上无参构造方法是一个良好的编程习惯

给全局变量赋值的时候，可以采用setter和getter方法，也可以采用构造方法赋值

一个最基本的类，书写应该具有的特点：

1.全局变量

2.构造方法

1.无参构造方法

2.有参构造方法

3.成员方法

1.get方法

2.set方法

static修饰的变量叫静态变量/共享变量/类变量（一般用于某个方法或某个成员变量与具体对象无关，即所有对象都具有的相同的变量或方法）

static 的特点：

1.静态变量属于某个类，不属于某个具体的对象

2.只有静态方法才能访问静态属性和静态方法，非静态变量不能出现静态方法中

3.访问静态成员的方式

1.类名.成员变量

2.类名.全局方法

4.静态环境下不能出现this和super关键字

5.static能够修饰全局变量，全局方法，内部类，修改类

6.开发自己的工具类的时候会经常用到static

代码块：

使用{}包裹的就是代码块。

1.局部代码块：

定义在类的局部位置，作用是：限定局部变量的作用域。

2.构造代码块：

定义类的成员变量的位置，用来抽取多个构造方法重复的代码，也可做全局变量的初始化操作，会优先于构造方法执行。

这三者的执行顺序：静态代码块>构造代码块>构造方法

静态代码块只执行一次，在类加载的时候。

构造代码块和构造方法在类对象创建的时候执行，可以执行很多次。

为什么要使用package？

1.可以处理类重名的问题。

2.方便管理数目众多的类。

包（package）的本质就是文件夹

1.在用一个包下面的类可以直接使用。

2.在java中java.lang包下面的所有的类型可以直接使用。

3.除了以上两点，其他类型的使用我们都必须通过import关键字来导入才可以使用。

imoport语法格式：

import 类的全路径

包名：满足标识符的规则和规范即可。

1.如果一个类不在任何一个包中，那么此类将无法被其他包导入使用，所以建议先创建包再创建类。

2.包的声明必须出现在第一句（注释除外），package语句在一个java文件中只能出现一句。

3.我们需要使用到某个包下面的多个类，这时候可以通过包名.*;的方式使用。

4.如果一个类文件需要使用到两个包下的同名的类中的属性，一个包通过import来导入，另一个包通过代码中全路径指定的方式创建对象进行引用。

以此来进行路径指定的创建对象的方式在另一个包中进行对Teacher类中属性的引用

5.定义类的时候不要和系统名相同。

（可以继承别的包中的类）

1.继承语法格式：class 子类名称 extends 父类名称

2.被继承的类称为父类、基类或者超类。

3.继承的这个类称为子类或者派生类。

4.java中不支持多继承，但是支持多层继承，即A继承B，B也继承了C，则A也相当于继承了C。

5.子类可以继承父类private修饰属性和方法，但是不可见，即虽然继承了，但是不可用。

6.子类不可以继承父类构造方法，只可以调用父类的构造方法。

7.子类除了继承父类的属性和方法以外，也可以添加自己的属性和方法。

1.简化了代码

2.提高了代码的可维护性

3.提高了扩展库

开发设计思想：高内聚低耦合（尽量在一个类里面内聚，类h和类之间的关系尽量保持独立）。

继承后耦合性提高，牵一发而动全身，这个缺点不能改进，所以在java中尽量不要使用继承，可以改用接口。

继承本质:简化代码

1.先写出所有子类，观察子类共有的成员变量和成员方法。

2.抽象出共同点，书写出父类。

3.让子类去继承父类，并把子类中的共有属性删除

子类中定义了一个和父类中同名的属性，子类中定义的同名的属性会覆盖掉父类中的属性

super关键字可以理解为父类对象，this关键字表示当前对象

当一个属性的使用没有添加this或者super关键字，那么他的查找顺序是：局部变量——>全局变量——>父类中的变量，如果还没找到就会报编译异常。

在构造方法中，默认都会添加y一句super()； 而且必须是第一行，即使不显示出来，也是默认有super的。

super和this关键字访问成员的区别

全局变量：

1.this.全局变量

2.super.成员变量 super是不能访问私有的全局变量的，可以通过访问对应的公有方法实现对私有全局变量的访问。

全局方法：

1.this.成员方法

2.super.成员方法

构造方法：

1.this(参数列表)；

2.super(参数列表)；

任何一个构造方法都默认的会在构造方法的第一句上写上super()；访问父类的无参构造方法，目的是初始化父类的成员变量。

super和this都是只能出现在构造方法的第一句，所以两者是无法在同一个构造方法中共存的。

static静态的上下文中也是不能出现super和this的。

1.父类中没有显式的写出无参和有参的构造方法时，子类中的有参和无参构造方法正常使用，不需要显式的写出super();

2.父类只显式的写出无参构造方法时，子类中的有参和无参构造方法正常使用，不需要显式的写出super();

3.父类中只显式的写了有参的构造方法时，子类中的构造方法第一行必须也显式的写出super关键字来引用父类中的构造方法，否则报错。引用格式：super(参数列表) 此处的参数列表需要和父类中的有参构造器中的参数列表一 一对应。

4.父类中显式的写出了无参和有参构造方法时，子类中的有参和无参构造方法正常使用，不需要显式的写出super();

super（）；调用的为父类中的无参构造方法

super（参数列表）；调用的为父类中的有参构造方法

作用：表示被修饰的元素的访问权限

访问权限修饰符有四个：public、protected、default、private

（不写任何的权限修饰符时即默认为default修饰）

1.类，只有public、abstra和final能修饰，或者不加。（private和protected可以修饰内部类）

2.全局变量

3.全局方法

1.public修饰的成员对一切类都可见

2.protected修饰的成员本包下都可见，不同包下只有子类可见。

3.default修饰的成员仅对同包下面的可见。

4.private修饰的成员仅对本类可见。

Java中的封装就是通过访问权限修饰符来实现的

public>protected>default>private

如果从父类继承的方法不能满足子类的需求的情况下，可以对其进行改写，这个过程叫方法的覆盖(override)，也被称为方法的重写，子类中出现了和父类中一模一样的方法声明，也称为方法的覆盖或方法的复写。

方法的重写的规则：

1.方法名称相同

2.参数列表相同

3.返回值类型相同或者返回值类型是父类的子类

4.访问权限修饰符不能严于父类

1.父类中的私有的方法不能被重写

2.构造方法不能被重写

3.子类重写父类中的方法时，访问权限不能更低

重载的定义：

1.在同一个类中

2.方法名称相同

3.参数列表不同(参数类型，顺序，个数)

4.和返回值以及访问权限修饰符没有关系

方法重写：在子类中，方法名要相同，参数列表要相同，返回值相同或者是父类的子类，访问权限修饰符不能严于父类中被重写的方法的访问权限修饰符

方法重载：在同类中，方法名相同，参数列表不相同，对返回值无要求，对访问权限修饰符无要求

修饰类：该类不能被继承 如：public final class Student(){}

修饰变量：变量会变为常量，只能赋值一次，之后就不能改变了，final修饰的变量称为常量，常量我们大都会声明为static，例如：final static String country;

final修饰的全局变量：在定义的同时必须给出初始值

final修饰的局部变量：可以先不初始化，可以在使用前赋值

final修饰的方法，子类是不能重写该方法的

同一个引用类型，使用不同的实例而执行不同的操作，即父类引用指向了子类对象。

在多态(父类指向子类的实现)的情况下，我们访问引用相关的成员(全局方法，全局变量，构造方法，静态方法)时的情况

在多态中，全局变量不存在覆盖的情况，在多态(父类指向子类的实现)的情况下，即父类和子类存在同名变量，此时访问的时候是直接访问的父类中的属性。

在多态中，因为方法存在重写，所以在访问的时候执行的是子类中重写的方法。

先执行父类的构造方法，可以帮我们初始化父类的全局变量，然后再执行子类的构造方法中其他的代码来实现子类成员变量的初始化。

在多态中，不会继承静态方法，因为静态方法是属于类的。所以在多态中我们调用静态方法那么执行的也是父类中的静态方法。

1.简化代码

2.提高扩展性

3.提高了程序的可维护性

1.使用父类作为一个方法的形参，如果一个父类作为参数，那么我们既可以传入父类对象，也可以传入对应的子类对象，这就是多态的常见使用。

2.使用父类作为一个方法的返回值，暂时先不讲，在后面结合抽象类和接口统一介绍。

在多态中如果我们想要调用子类特有的方法及属性时是实现不了的。

多态中的类型转换：

格式：<父类型> <引用变量名> = new <子类型>();

特点：

子类转为父类，父类的引用指向子类对象，自动进行类型转换。此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法。此时通过父类引用变量无法调用子类特有的属性和方法。

格式:<子类型><引用变量名> = (<子类型>) <父类型的引用变量>;

特点：

父类转为子类，父类引用转为子类对象，强制类型转换。

在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常。

测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。 当对象是右边类或子类所创建对象时，返回true；否则，返回false。

记住：instanceof通常和向下转型(强制类型转换)结合使用。

被abstract关键字修饰的类，被称为抽象类

被abstract关键字修饰的方法，被称为抽象方法，抽象方法是没有方法体的，抽象方法必须定义在抽象类中。

abstract class 类名()

abstract 返回值类型 方法名(参数列表)

1.抽象类和抽象方法一定要使用abstract关键字

2.抽象类不一定有抽象方法

3.没有抽象方法的抽象类的存在y意义是什么？就是不让外界创建对象。即抽象类不能被实例化。

4.抽象类虽然不能被实例化，但是我们可以利用多态的思想赋值。

例如：Pet类是抽象类，并且也是Dog类的父类，Dog类是个普通类。

即Pet p1 = new Dog();

p1.eat();

Pet抽象类中无任何抽象方法，通过多态的思想就可以调用到子类中的方法。

5.作为抽象类的子类应该怎么办？

子类有两个选择：

1.把子类自身也变为抽象类。

2.实现父类中的所有的抽象方法，此时子类不需要变成抽象类。(如果User类不能实现Person类中的全部两个抽象方法，只能实现一个，则User类也必须变成抽象类。而Person类中剩下的那个抽象方法则再交给Usr类的子类去实现)

6.抽象类中除了抽象方法还可以包含哪些内容？

全局变量、全局方法、常量、构造方法、静态方法、代码块、静态代码块，全都可以。

抽象类本身是不能够被实例化的，所以抽象类就是一个用类给子类服务的类。

7.static、final、private是否可以修饰抽象方法？

1.static和abstract：是不能够共存的。static是为方便调用，abstract为了给子类重写的，没有方法体。

2.final和abstract：是相互冲突的，final修饰的方法不能被重写，而abstra修饰的方法就是为了让子类重写的。

3.private和abstract：也是冲突的，private修饰的方法不能够被继承，也就不能够被重写，而abstract修饰的方法就是为了让子类重写的。

1.抽象类的所有的抽象方法都是用来给子类重写的。

2.抽象类的所有的非抽象方法也是用来给子类使用的。

3.抽象类的构造方法也是用来给子类初始化从父类继承过来的成员。

4.抽象类的全局变量也是用来给子类使用。

5.抽象类就是一个彻头彻尾的服务类。

1.接口是可以扩展功能的。

2.接口是一种规范，一种标准。

3.接口是灵活的。

接口是抽象方法和常量的集合，JDK1.8之后接口中可以包含静态方法和默认方法。

接口格式：

关键字 接口名{

常量；

抽象方法；

}

即 interface 接口名{

。。。。

}

2.1

常量：默认接口中所有的成员的变量都是省略public static final这几个关键字的，即定义变量时候不加static final关键字，但是在接口中也是默认含有的，一般接口的成员变量都是大写的。

抽象方法：默认接口中的所有成员方法都是省略public abstract。即不加abstract关键字，在接口中，也是默认含有的。

3.1 接口中存在抽象方法，那就表明接口本身也是一个抽象类，所以肯定不能被实例化，那么此时我们只能通过接口的实现类来实现接口，要实现接口的实现类我们通过Implements关键字来实现。

1.子类不想实现父接口中定义的抽象方法那么可以定义本身为一个接口。即 imterface 子类名 extends 父接口名

2.如果一个类实现了接口，那么该类就必须实现接口中所定义的所有的抽象方法。

3.如果一个接口不想实现接口的方法，那么子类必须定义为一个接口或者抽象类。即：

imterface 子类名 extends 父接口名 或者

abstract class 子类名 implements 父接口名

4.接口可以被类多实现，相比较继承的单继承而言，接口在这方面就显得很灵活，支持多实现。即：类1 implements 接口名1，接口名2

5.接口继承接口，抽象方法也被继承。

6.在Java中接口与接口是可以多继承的！！！

即 interface 接口1 extends 接口2 ，接口3，但是要实现被继承的所有接口中的抽象方法。

类和类：单继承，不可以实现

类和接口：单继承，多实现

接口和接口：多继承，不能实现

当我们设计一个非常复杂而又无法实现的类的时候可以使用继承。

当我们重新开始编写一些简单的功能或者指定一些标准的时候使用接口。

开发中一般采用面向接口编程，抽象类是模板，接口是规范。

可以把每个功能定义成接口，每个不同的功能的接口中有不同功能的抽象方法，然后不同设备实现不同接口

什么是多态：父类的引用指向子类的实例

多态的实现方法：

1.使用父类作为方法的形参实现多态。

2.使用父类作为方法的返回值实现多态。

继承多态：当这个作为参数的父类是普通类或者抽象类时。

接口多态：当这个作为参数的父类是一个接口时，构成接口多态。

1.基本数据类型

基本数据类型作为形参，就是我们讲的值传递

2.引用类型

普通 类：当一个形参希望我们传递的是一个普通类时，我们实际传递的是该类的对象/匿名对象

抽象类：当一个形参希望我们传入是y一个抽象类时，实际上传入的是该类的子类对象/子类匿名对象

接口：当一个形参希望我们传入是y一个抽象类时，实际上传入的是该接口的实现类对象/实现类的匿名对象

1.基本数据类型：

基本数据类型作为返回值，就是我们讲的值传递。

2.引用类型：

普通类：当一个方法的返回值是一个普通类，实际返回的就是该类的对象，我们可以使用该类的对象接收。

抽象类：当一个方法的返回值是一个抽象类时，实际返回的是该抽象类的子类对象，我们可以使用该抽象类接收，如果用该类的子类来接收，那么就要考虑类型的强制转换问题。

接口：当一个方法的返回值是一个接口时，实际返回的是该接口的实现类对象，我们可以接口来接收，同样的如果我们使用实现类来接收的话，同样可能出现ClassCastException的问题，即强制类型转换的问题。

将类定义在类的内部，那么该类就称为内部类。

注意：内部类是一个相对的概念，如果Outter类中有一个inner类，那么Outter类相对于inner类来说就是外部类，而inner类相对于Outter类来说就是内部类。

Java中不能被实例化的类型有哪些？ 1. 抽象类 2. 接口 3. 所有的构造方法都被private修饰的类型 4. 内部类不能被外界直接实例化

1.内部类可以直接访问外部类中的所有的成员(变量和方法)

2.外部类如果要访问内部类成员，必须在外部类或外部类方法体中中创建内部类对象来实现。

3.要访问内部类的成员是非常麻烦d的，而且造成程序耦合性强，可读性降低，所以内部类慎用。

我们在外部类中定义一个成员内部类，这个内部类和外部类中的成员变量成员方法是同级的。

因为内部类非私有，所以我们可以通过如下格式直接获取内部类对象： 外部类.内部类 变量名称 = 外部类对象.内部类对象;

例如：Outter.Inner in = new Outter( ).new Inner( );

内部类作为外部类的成员，是可以用private来修饰的，普通的类不可以，既然用private修饰也就意味着外界是没办法直接获取该内部类对象的，同时我们也没法通过相关的类型来接收，但是我们可以在外部类中提供相关的getter/setter方法来处理。

成员内部类可以理解为和成员变量同级，那么局部内部类我们也可以理解为和局部变量同级的内部类

被static修饰的成员内部类我们称为静态内部类。

获取静态内部类实例的语法格式：

外部类名.内部类名 变量名称 = new 外部类.内部类( );

静态内部类相比于成员内部类来说简化了方法方式，好处是同样的提高了类型安全性。

静态内部类特点：

外部类名称.内部类名称.静态方法( );

外部类名称.内部类名称.静态变量名;

匿名内部类是java为了方便我们编写程序而设计的一种机制，因为有时候有的内部类只需要创建一个对象就可以了，这时候匿名内部类就比较合适，匿名内部类一般都是和接口以及抽象类相关联的。