今日整理:
1.什么是继承?它有什么好处和坏处?
2.两个类若是有继承关系,如何进行访问(变量和方法)?
3.什么是方法的重写?它有什么需要注意的地方?
4.今天讲了哪些修饰符?各有什么作用和特点?
5.聊聊今天你觉得重要的点.

今日整理:
1.什么是继承?它有什么好处和坏处?
答:继承就是将类中共用的属性(成员变量)和行为(成员方法)派生出一个父类.这个过程就是继承
     好处是:挺高了代码的复用性;
                便于后期的维护;
     坏处是:父类和子类的代码耦合度过高.
2.两个类若是有继承关系,如何进行访问(变量和方法)?
  答:this 可以操作当前类的的成员变量,成员方法，构造方法。
      super 可以操作父类的成员变量,成员方法，构造方法。
3.什么是方法的重写?它有什么需要注意的地方?
  答:在子类中定义一个和父类里面一模一样的方法就是方法的重写.
      父类中私有的方法不能被重写
     子类重写父类重的方法：那么方法的访问权限修饰符，子类的重写方法的修饰符大于等于父类的。
4.今天讲了哪些修饰符?各有什么作用和特点?
   答:
        public:被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问
        protectd:可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外)
        defult:使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的
        private:私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类                   访问，并且类和接口不能声明为 private。
        final:final修饰的变量时基本类型：表示基本类型的值不能修改了
                final修饰的变量时引用类型：表示引用类型的地址值不能改变（引用类型的值可以改变）
        static:调用静态变量和方法时，可以使用对象来调用，可以使用类名直接调用
5.聊聊今天你觉得重要的点.
答:继承和重写.

今日整理:
1.什么是继承?它有什么好处和坏处?
在子类中相同的属性变量和行为方法派生出新的的父类，这个过程就是继承；
好处：①提高代码复用性②方便后期对代码的管理；坏处：①子类和父类耦合性太高
2.两个类若是有继承关系,如何进行访问(变量和方法)?
访问变量：①访问在子类中方法内的变量，访问的是局部变量；②访问在子类中方法外的变量时，访问成员变量；③子类中没有变量时访问父类中的变量；④父类中没有变量时报错；⑤子类和父类中都有相同变量时用super区分；⑥子类中和方法内都有相同变量时用this区分成员变量和局部变量。
访问方法：①子类中有方法时访问子类中的方法；②子类中没有方法时访问父类中的方法；③子类和父类中都没有方法是报错。④子类和父类中方法重名时使用super来区分。
3.什么是方法的重写?它有什么需要注意的地方?
在子类中定义一个和父类中一模一样的方法就是方法的重写。
注意点：①使用@Override判断是否为重写的方法；②父类中私有的方法不能重写；③子类重写方法时的修饰符大于或等于父类。
4.今天讲了哪些修饰符?各有什么作用和特点?
访问权限修饰符①public：被public声明的变量、方法、构造方法、类、接口可以被其它类访问②默认：被默认修饰符修饰的变量和方法在同一个包中可以被访问③protected：protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。④private：被private声明的变量、方法、构造方法只有所属的类能访问，且不能声明类和接口，提供了Get和Set方法被外部访问。
非访问权限修饰符①final：可修饰类、变量、方法，修饰的变量是基本类型时变量值不可改变；修饰的变量为引用类型时变量地址值不能改变②static：可修饰变量、方法、代码块，被修饰的变量和代码块只会初始化一次。
5.聊聊今天你觉得重要的点.
①继承；②方法的重写；③this和super的区别和用法

今日整理:
1.什么是继承?它有什么好处和坏处?
  继承：就是将子类中的共同属性(成员变量)和行为(成员方法)派生出一个新的父类，这个过程称为继承
  继承的好处：
    1.提高代码的复用性
    2.提高代码的维护性(在父类中修改属性和行为，子类不用修改)
  继承的坏处：
    父类和子类的耦合度提高
    耦合度：类与类之间的关系，耦合指的是子类与父类之间有关联关系
    解决耦合度方法：利用方法重写
2.两个类若是有继承关系,如何进行访问(变量和方法)?
  类A extend 类B
  访问变量和方法通过this和super来实现
  this与super之间的区别：
  1.this表示当前类对象，super表示父类的对象
  2.this可以在任意类里使用，super只能在有继承关系的子类里面使用
  3.在无参构造方法里：不能直接使用this；在无参构造方法里，直接使用super
3.什么是方法的重写?它有什么需要注意的地方?
  方法的重写：在子类中，定义一个和父类中一样的方法，该操作称为方法的重写
  注意：
   1：通过@Override来区别子类中的方法是否是重写方法
   2：父类中的私有方法不能被重写
   3：子类重写父类中的方法需要注意修饰符：public>protected>=默认>private
4.今天讲了哪些修饰符?各有什么作用和特点?
  1：访问权限修饰符：public、protected、默认、private
    public：被其修饰的类、方法、构造方法和接口能被其他类访问
    protected：注意从子类与基类是否在同一包中来区别使用
    默认：被其修饰的变量或方法，对同一个包内的类是可访问的
    private：外部类要访问需通过setter()和getter()方法
  2：非访问权限修饰符：final
    final：
    1：被其修饰的类、方法、变量大多数不能被访问
    2：基本类型变量被修饰是不能修改的；引用类型变量被修饰，其地址不能改变，值可改变
  3：static修饰符
    static：
    1：在普通方法里面
    a:直接使用非静态变量和非静态方法
    b:可以直接使用静态变量和静态方法
    2：在静态方法里面
    a:不能直接使用非静态变量和非静态方法
    b:可以直接使用静态变量和静态方法
5.聊聊今天你觉得重要的点.
  1：继承的使用
  2：继承中访问成员方法
  3：继承访问构造方法
  4：this和super的联系与区别
  5：访问权限修饰符的区别public-protected-默认-private
  6：非访问权限修饰符final的用法与注意事项
  7：static修饰的方法与变量使用

1.什么是继承?它有什么好处和坏处?
答：继承就是将子类中的共同属性（成员变量）和行为（成员方法）派生出一个新的父类
这个过程就是继承。
继承优点：
1. 提高代码的复用性
2. 便于代码后期的维护（在父类中修改属性和方法，子类不用修改）
   比如：在父类中修改代码，子类里面可以不用修改了。
继承缺点：
        父类和子类的代码耦合度很高。
        比如：父类定义好了方法，但是子类对于这个方法的功能有的不需要，修改了父类中的方法，子类的方法执行会受影响，   削弱子类的独立性。         
        解决耦合：方法的重写。

2.两个类若是有继承关系,如何进行访问(变量和方法)?
答：在子类中访问变量
  * 如果方法内部有这个变量，优先使用方法内部的局部变量
  * 如果子类中有这个变量，方法内部没有这个变量，在方法内部使用子类的成员变量
  * 如果子类没有这个变量，方法内部也没有这个变量，在方法内部会使用父类的变量
  * 如果父类中也没有这个变量，编译报错了
    注意：
    1.方法内部和子类中都有这个变量，使用this来区分局部和成员变量,
    2.子类中和父类都有这个变量使用super区分子类的变量和父类的成员变量
继承中访问成员方法
- 如果子类中有这个方法，优先使用子类中的方法
- 如果子类中没有这个方法，会去使用父类中的方法
- 如果父类中没有这个方法，编译报错了
  注意：如果子类和父类的方法重名了，使用super关键词区分
3.什么是方法的重写?它有什么需要注意的地方?
答：重写的概述
在子类中，定义一个和父类中一模一样的方法，这个操作就叫方法的重写。
优点：
保证子类方法执行时的独立性
注意事项
     *.怎么判断子类中的方法是否时重写的方法，可以使用注解@Override
     如果编译没有报错，就是重写的方法，编译报错了，不是重写的方法
   *父类中私有的方法不能被重写
    *子类重写父类重的方法：那么方法的访问权限修饰符，子类的重写方法的修饰符大于父类的。
      访问权限修饰符： public >= protected => 默认
4.今天讲了哪些修饰符?各有什么作用和特点?
答：权限修饰符   
   *public： 被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问
   *protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）
     - 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
     - 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法
   *默认的  使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
   *private 私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
     声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
     private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
总结：实际开发中，用public居多，private修饰的变量通常会提供对应的setter和getter方法。
非访问权限修饰符
   * final 它表示最终的意思，它可以修饰类，修饰方法，修饰变量 在实际开发中，通常使用final修饰变量
      final修饰的变量时基本类型：表示基本类型的值不能修改了
      final修饰的变量时引用类型：表示引用类型的地址值不能改变（引用类型的值可以改变）
      在继承时，如果在父类中使用了final
        1.如果这个类被final修饰，那个类不能被继承
        2.如果这个类中 的变量被final修饰了，那个变量可以被继承，不能做修改
        3.如果这个类中 的方法被final修饰了，那个方法也不能被继
    *static修饰符    静态的。它可以修饰成员变量，成员方法，代码快
         - static特点：
          凡是类中被static修饰的变量，代码快，只会初始化一次。
          优点：提高代码的执行性能（效率）
  应用场景：
                    静态代码块的用途：加载配置文件，加载一次（后面详细讲）
- 静态变量和方法，以及普通方法和方法使用范围
  - 在普通方法里面：
    直接使用非静态变量和非静态方法，
    也直接使用静态变量和静态方法
  - 在静态方法里面
    不能直接使用非静态变量和非静态方法，
    可以直接使用静态变量和静态方法。
  - 注意：
    调用静态变量和方法时，可以使用对象来调用，可以使用类名直接调用（推挤使用的）
5.聊聊今天你觉得重要的点.
继承的使用场景。

今日整理:
1.什么是继承?它有什么好处和坏处?
继承是将子类中的共同属性（成员变量）和行为特性（成员方法）的事物抽取出来，派生成一个类。
好处：提高代码的复用性。便于子代码后期的维护。
坏处：父类和子类的耦合度很高
2.两个类若是有继承关系,如何进行访问(变量和方法)?
在子类中访问变量
如果方法内部有这个变量，优先使用方法内部的局部变量
如果子类中有这个变量，方法内部没有这个变量，在方法内部使用子类的成员变量
如果子类没有这个变量，方法内部也没有这个变量，在方法内部会使用父类的变量
如果子类中有这个方法，优先使用子类中的方法

如果子类中没有这个方法，会去使用父类中的方法


3.什么是方法的重写?它有什么需要注意的地方?
在子类中，定义一个和父类中一模一样的方法，这个操作就叫方法的重写
父类中私有的方法不能被重写
子类重写父类重的方法：那么方法的访问权限修饰符，子类的重写方法的修饰符大于父类的。
4.今天讲了哪些修饰符?各有什么作用和特点?
访问权限修饰符：public protected 默认的 private
非访问权限修饰符:final static
final修饰的基本类型的值不能改变，修饰的引用类型的地址值不能改变。
凡是类中被static修饰的变脸，代码块。只会被初始化一次。
5.聊聊今天你觉得重要的点.
import 导入使用类的对用包名。使用*代替。
this和super的区别
表示的对象不同：
  this表示当前类对象
  
super表示父类对象

使用范围
  this可以在任意类里面使用
  super只能在有继承关系的子类里面使用。
-
在调用构造方法时
  在无参构造方法里面：不能直接使用this();
  在无参构造方法里面：直接使用super();

今日整理:
1.什么是继承?它有什么好处和坏处?

        继承：继承就是将子类中的共同属性（成员变量）和行为（成员方法）派生出一个新的父类
        好处：1. 提高代码的复用性
                  2. 便于代码后期的维护（在父类中修改属性和方法，子类不用修改）
        坏处：父类和子类的代码耦合度很高。


2.两个类若是有继承关系,如何进行访问(变量和方法)?

        public class  类名A  extends  类名B{

        //定义类名A特有的属性和行为，不用在书写B里面的属性和行为，默认就有

    }
        然后通过创建A的对象，通过A的对象.调用父类的变量和方法



3.什么是方法的重写?它有什么需要注意的地方?

        方法的重写：在子类中，定义一个和父类中一模一样的方法，这个操作就叫方法的重写。
        注意事项：
                1）.怎么判断子类中的方法是否时重写的方法，可以使用注解@Override
                如果编译没有报错，就是重写的方法，编译报错了，不是重写的方法
                2）.父类中私有的方法不能被重写
                3）.子类重写父类重的方法：那么方法的访问权限修饰符，
                子类的重写方法的修饰符大于父类的。
                访问权限修饰符： public > protected > 默认


4.今天讲了哪些修饰符?各有什么作用和特点?

        package：包
        作用：管理类的，通过包来区分相同的类的。
       
        import：导入
        作用:
                1）.import :用来确定在当前类里面使用的是那个package包下面的类
                2）.简化包的书写。

        权限修饰符：
                   本类   同一个包下(子类和无关类)   不同包下(子类)     不同包下(无关类)
        private        Yes      
        默认           Yes                    Yes
        protected      Yes                       Yes                   Yes
        public         Yes                    Yes                   Yes                           Yes

        非访问权限修饰符：
        final：
                它可以修饰类，修饰方法，修饰变量它可以修饰类，修饰方法，修饰变量
                final修饰的变量时基本类型：表示基本类型的值不能修改了
                final修饰的变量时引用类型：表示引用类型的地址值不能改变（引用类型的值可以改变）
        final特点：
                fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
                final修饰方法：该方法不能被重写
                final修饰变量：表明该变量是一个常量，不能再次赋值

        static：
                静态的。它可以修饰成员变量，成员方法，代码快
        static特点：
                凡是类中被static修饰的变量，代码快，只会初始化一次。
                优点：提高代码的执行性能（效率）


5.聊聊今天你觉得重要的点.

        A、权限修饰符和非访问权限修饰符特点和作用
        B、继承，方法重写
        C、this和super的作用和区别
        D、java中的继承特点

今日整理:
1.什么是继承?它有什么好处和坏处?
可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法。
提高了代码的复用性(多个类相同的成员可以放到同一个类中)；提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
2.两个类若是有继承关系,如何进行访问(变量和方法)?
在子类方法中访问一个变量，采用的是就近原则。子类局部范围找，子类成员范围找，父类成员范围找，如果都没有就报错(不考虑父亲的父亲…)
3.什么是方法的重写?它有什么需要注意的地方?
子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）。当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
4.今天讲了哪些修饰符?各有什么作用和特点?
final和static
5.聊聊今天你觉得重要的点.
非静态方法不能访问静态方法和静态变量。

今日整理:
1.什么是继承?它有什么好处和坏处?
   将具有共同属性和行为的事物抽取出来，派生出一个新的类的过程就是继承。
   好处：提高代码的复用性和维护性
   坏处：提高了耦合度
2.两个类若是有继承关系,如何进行访问(变量和方法)?
   在子类方法访问变量采取就近原则
   如果子类中有要调用的方法，优先使用子类的方法，如果子类和父类有共同方法，使用
   super关键词区分
3.什么是方法的重写?它有什么需要注意的地方?
   在子类中定义一个与父类中一模一样的方法（名称，参数列表一致，可使用Override注解来检测方法是否为重写）
   注意：父类中私有方法不能被重写
             重写的方法访问权限修饰符要大于等于父类       
4.今天讲了哪些修饰符?各有什么作用和特点?
   final修饰符：可以修饰类、方法和变量，如果用它修饰基本类型，那基本类型的值不能再更改，
   ，如果修饰引用类型，引用类型的地址值不能再更改，如果修饰类，类将不能被继承
   static修饰符：静态的意思，可以修饰成员方法和成员变量，普通方法可以直接调用静态方法，静
   态方法不能直接调用非静态方法但可以直接使用静态方法
5.聊聊今天你觉得重要的点.
（1）继承的使用和特点
（2）有继承关系的类调用方法时需要使用this和super来区分
（3）权限修饰符的特点和访问范围
（4）final和static的使用和注意事项

今日整理:
1.什么是继承?它有什么好处和坏处?
       
继承是面向对象的三大特征之一。即将具有相同属性和行为特征的事物派生出一个新的类，当类进行继承之后，他会具有父类的属性和方法，也可以在子类中重新定义
好处：可以减少代码的重复编写，提高代码复用性；
      可以提高代码的维护性，即要修改代码时只要修改一个地方即可。
坏处：增加了类的耦合性，削弱了子类的独立性

2.两个类若是有继承关系,如何进行访问(变量和方法)?
采用一个“就近原则”。
访问变量：即在一个类中。如果方法内有要访问的变量，优先使用方法内部的局部变量；如果类中有这个变量，方法中没有，就会去找方法内部的子类的成员变量；如果子类中和方法内部都没有这个变量，就会去调用父类的变量；如果都没有，就会编译出错
访问方法：也是就近原则，即如果子类中有要调用的方法，就优先使用子类的方法；如果没有，就会去使用父类的方法；如果都没有，就会出现编译错误。




3.什么是方法的重写?它有什么需要注意的地方?

子类和父类方法声明完全一样即是重写
注意：私有方法不能被重写；子类的方法访问权限要比父类高


4.今天讲了哪些修饰符?各有什么作用和特点?

final： 作用：用来修饰最终的方法，类等    特点：修饰过的类不能被继承；修饰过的方法不能被修改；修饰过的变量不能再次被赋值；修饰过的引用类型的地址值不能改变但是值可以变
public  是最高级的权限修饰符。在同一个类中；同一个包中子类无关类；不同包的子类；不同包的无关类都可以访问       
protect 是第二高的权限修饰符。在同一个类中；同一个包中子类无关类；不同包的子类都可以访问；不同包的无关类不可以访问
默认        是第三高的权限修饰符。在同一个类中；同一个包中子类无关类都可以访问；不同包的子类，不同包的无关类都不可以访问
private 是最低的权限修饰符。只有在同一个类中才可以访问
static  用来修饰静态的方法和变量  特点：被类的所有对象共享，也可以通过类名和对象名调用


5.聊聊今天你觉得重要的点.
继承的概述，优缺点，耦合度，继承的时候访问变量和方法是如何访问，访问构造方法，this和super区别以及联系，重写是什么，关键词是什么，权限修饰符包括哪几类，分别有什么 有什么特点作用

1.什么是继承?它有什么好处和坏处?
***将子方法中共同属性和行为特性的事物抽取 出来派生一个新的类
2.两个类若是有继承关系,如何进行访问(变量和方法)?
* 如果方法内部有这个变量，优先使用方法内部的局部变量

  * 如果子类中有这个变量，方法内部没有这个变量，在方法内部使用子类的成员变量

  * 如果子类没有这个变量，方法内部也没有这个变量，在方法内部会使用父类的变量

  #- 如果子类中有这个方法，优先使用子类中的方法
- 如果子类中没有这个方法，会去使用父类中的方法

3.什么是方法的重写?它有什么需要注意的地方?
   ##在子类中，定义一个和父类中一模一样的方法，这个操作就叫方法的重写。
   ##注意事项：

       1.怎么判断子类中的方法是否时重写的方法，可以使用注解@Override

        如果编译没有报错，就是重写的方法，编译报错了，不是重写的方法

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

        3.子类重写父类重的方法：那么方法的访问权限修饰符，子类的重写方法的修饰符大于父类的。

4.今天讲了哪些修饰符?各有什么作用和特点?
    #权限修饰符：
        public ： 被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
        protected：protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
        默认的：使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。
                     接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
        private：私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

今日整理:
1.什么是继承?它有什么好处和坏处?
答：

##继承的概念：
继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

##实现继承的格式：
继承通过extends实现
格式：class 子类 extends 父类 { }
举例：class Dog extends Animal { }

##继承带来的好处：
1.继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。
2.提高了代码的复用性(多个类相同的成员可以放到同一个类中)
3.提高了代码的维护性(如果方法的代码需要修改，修改一处即可)

##继承的弊端：
继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削
弱了子类的独立性

2.两个类若是有继承关系,如何进行访问(变量和方法)?
答：

###在子类方法中访问一个变量，采用的是就近原则。
1. 子类局部范围找
2. 子类成员范围找
3. 父类成员范围找
4. 如果都没有就报错(不考虑父亲的父亲…)

###通过子类对象访问一个方法，
1. 子类成员范围找
2. 父类成员范围找
3. 如果都没有就报错(不考虑父亲的父亲…)

## 继承中构造方法的访问特点
注意：子类中所有的构造方法默认都会访问父类中无参的构造方法
子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super()


###如果我们为了区别访问父子类中的变量和方法，可以使用this&super关键字：
this：代表本类对象的引用
super：代表父类存储空间的标识(可以理解为父类对象引用)

**this和super的使用分别：

*成员变量：
this.成员变量 - 访问本类成员变量
super.成员变量 - 访问父类成员变量
*成员方法：
this.成员方法 - 访问本类成员方法
super.成员方法 - 访问父类成员方法
*构造方法：
this(…) - 访问本类构造方法
super(…) - 访问父类构造方法

3.什么是方法的重写?它有什么需要注意的地方?
答：

###方法重写概念
子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
###方法重写的应用场景
当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
###Override注解
用来检测当前的方法，是否是重写的方法，起到【校验】的作用

###方法重写的注意事项
1. 私有方法不能被重写(父类私有成员子类是不能继承的)
2. 子类方法访问权限不能更低(public > 默认 > 私有)

4.今天讲了哪些修饰符?各有什么作用和特点?
答：

###package（了解）
1、包的概念
包就是文件夹，用来管理类文件的
2、包的定义格式
package 包名; (多级包用.分开)
例如：package com.heima.demo;
3、带包编译&带包运行
带包编译：javac –d . 类名.java
例如：javac -d . com.heima.demo.HelloWorld.java
带包运行：java 包名+类名
例如：java com.heima.demo.HelloWorld

###import（理解）
1.导包的意义：
使用不同包下的类时，使用的时候要写类的全路径，写起来太麻烦了，为了简化带包的操作，Java就提供了导包的功能
2.导包的格式
格式：import 包名;
范例：import java.util.Scanner;

###访问权限修饰符
- public： 被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
- protectd：需要从以下两个点来分析说明：
  *子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
  *子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
  protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
- 默认的：使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
- private：私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
  声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
  private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。


###final（应用）
fianl关键字的作用：代表最终的意思，可以修饰成员方法，成员变量，类
final修饰类、方法、变量的效果
fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
final修饰方法：该方法不能被重写
final修饰变量：表明该变量是一个常量，不能再次赋值

final修饰局部变量（理解）
fianl修饰基本数据类型变量：基本类型的数据值不能发生改变
final修饰引用数据类型变量：引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的


###static
static的概念
static关键字是静态的意思，可以修饰【成员方法】，【成员变量】
static修饰的特点
1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
2. 可以通过类名调用当然，也可以通过对象名调用【推荐使用类名调用】


5.聊聊今天你觉得重要的点.
以上我所写的，都非常重要，要充分理解并应用

今日整理:
1.什么是继承?它有什么好处和坏处?
        继承：当子类中的共同属性（成员变量）和共同行为（成员方法）抽取出来，
        派生成一个新的类的过程就叫继承，派生出来的新的类就是父类。
2.两个类若是有继承关系,如何进行访问(变量和方法)?
继承访问变量：
        ①.如果方法内部有变量，优先使用方法内部的变量(局部变量)；
                ②.如果子类中有这个变量，方法内部没有这个变量，在方法内部使用子类的成员变量；
                ③.如果子类没有这个变量，方法内部也没有这个变量，在方法内部使用父类的变量；
                ④.如果父类中也没有这个变量，编译报错。
继承访问成员方法：
        ①.如果子类中有这个方法，优先使用子类中的方法；
                ②.如果子类中没有这个方法，使用父类中的方法；
                ③.如果父类中没有方法， 编译报错；
                ④.如果子类方法和父类方法重名，使用super来区分，super调用父类方法。
继承访问构造方法：
                ①.this(参数)调用子类的有参构造方法；
                ②.super()调用父类的的无参数的构造方法，这是默认的；
                ③.super(参数)调用父类的有参的构造方法；
                ④.this(),super()必须放在构造方法的第一行；
                ⑤.this(),super()不能同时使用。
3.什么是方法的重写?它有什么需要注意的地方?
重写：在子类中，定义一个和父类中一模一样的方法，这个操作就叫做重写。
注意事项：
        ①.怎么判断子类中的方法是否时重写的方法，可以使用注解@Override
        如果编译没有报错，就是重写的方法，编译报错了，不是重写的方法
        ②.父类中私有的方法不能够重写。
        ③.子类重写父类的方法，那么子类重写方法的访问权限修饰符要大于父类
        public >= protected => 默认
4.今天讲了哪些修饰符?各有什么作用和特点?
权限修饰符：
      public修饰符：被声明的public的类，方法，构造方法和接口能够被其他类访问。
      protected修饰符：当子类与父类在同一个包中时，被protected声明的变量，方法和构造方法能被同一个包中的其他类访问。
        当子类和父类不在同一个包中时，在子类中，子类实例可以访问其他从父类继承而来的protected方法，但不能访问父类实例的protected方法。
      private修饰符：被private声明的方法，变量和构造方法只能被所属的类访问，并且类和接口不能声明为private。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
默认修饰符：使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
非权限修饰符：
      final修饰符：可以修饰类，修饰方法，修饰变量。
        如果final修饰的变量是基本类型：基本类型的值不能修改
        如果final修饰的变量是引用类型：引用类型的地址值不能改变（引用类型的值可以改变）
        在继承时，如果父类使用了final：
                ​1.如果这个类被final修饰，那个类不能被继承
                2.如果这个类中 的变量被final修饰了，那个变量可以被继承，不能做修改
                3.如果这个类中 的方法被final修饰了，那个方法也不能被继承
      static修饰符：可以修饰成员变量，成员方法和代码块。
        凡是类中被static修饰的变量，代码快，只会初始化一次，提高代码的执行效率
         在普通方法里面：
                 直接使用非静态变量和非静态方法，也直接使用静态变量和静态方法
         在静态方法里面：
                不能直接使用非静态变量和非静态方法，可以直接使用静态变量和静态方法。
        调用静态变量和方法时，可以使用对象来调用，可以使用类名直接调用。
5.聊聊今天你觉得重要的点.
        1.关于继承的概念，以及继承的使用，包括继承访问变量，继承访问成员方法，继承访问构造方法等，以及继承执行的顺序。
        2.this和super的区别：
                this表示当前类对象的引用，this可以在任意类中使用。在无参构造方法里面，不可以直接使用this();
                super表示父类对象的引用，在子类中，可以通过使用super操作父类的成员变量，成员方法和构造方法。在无参构造方法里面，可以直接使用super();
        3.方法的重写：在子类中，定义一个和父类中一模一样的方法，这个操作就叫方法的重写。
               优点：保证子类方法执行时的独立性。
            可以使用注解@Override判断子类中的方法是否时重写的方法。
        4.public，private，protected，默认修饰符的作用，区别。
        5.final修饰符的使用，static修饰符的使用。

1.什么是继承?它有什么好处和坏处?
继承就是把类具有的相同的属性和行为派生出新的一个类
好处：它会增加代码的复用性，提高可维护性
坏处：代码耦合
2.两个类若是有继承关系,如何进行访问(变量和方法)?
就近原则
如果变量名（方法名）相同，用this（谁调用谁就是this）和super（父类）来区分
3.什么是方法的重写?它有什么需要注意的地方?
方法重写就是在子类中定义一个和父类一模一样的方法
子类的修饰符要大于或等于父类的修饰符（public>=protected>=默认）
父类私有的方法不能重写
4.今天讲了哪些修饰符?各有什么作用和特点?
权限修饰符：
      public修饰符：被声明的public的类，方法，构造方法和接口能够被其他类访问。
      protected修饰符：当子类与父类在同一个包中时，被protected声明的变量，方法和构造方法能被同一个包中的其他类访问。
        当子类和父类不在同一个包中时，在子类中，子类实例可以访问其他从父类继承而来的protected方法，但不能访问父类实例的protected方法。
      private修饰符：被private声明的方法，变量和构造方法只能被所属的类访问，并且类和接口不能声明为private。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
默认修饰符：使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
非权限修饰符：
      final修饰符：可以修饰类，修饰方法，修饰变量。
        如果final修饰的变量是基本类型：基本类型的值不能修改
        如果final修饰的变量是引用类型：引用类型的地址值不能改变（引用类型的值可以改变）
        在继承时，如果父类使用了final：
                ​1.如果这个类被final修饰，那个类不能被继承
                2.如果这个类中 的变量被final修饰了，那个变量可以被继承，不能做修改
                3.如果这个类中 的方法被final修饰了，那个方法也不能被继承
      static修饰符：可以修饰成员变量，成员方法和代码块。
        凡是类中被static修饰的变量，代码快，只会初始化一次，提高代码的执行效率
         在普通方法里面：
                 直接使用非静态变量和非静态方法，也直接使用静态变量和静态方法
         在静态方法里面：
                不能直接使用非静态变量和非静态方法，可以直接使用静态变量和静态方法。
        调用静态变量和方法时，可以使用对象来调用，可以使用类名直接调用。
5.聊聊今天你觉得重要的点.
继承的运用，区分父类和子类的调用
修饰符的权限
static修饰符的使用

1.继承就是将子类中的共同属性（成员变量）和行为（成员方法）派生出一个新的父类
好处：1. 提高代码的复用性  2. 便于代码后期的维护   坏处：父类和子类的代码耦合度很高

2.    先创建子类对象，用子类对象调用父类的变量和方法，如： 对象名.父类变量；对象名.父类方法名()

3.  在子类中，定义一个和父类中一模一样的方法，这个操作就叫方法的重写。
    注意事项：
        1.怎么判断子类中的方法是否时重写的方法，可以使用注解@Override
        如果编译没有报错，就是重写的方法，编译报错了，不是重写的方法
        2.父类中私有的方法不能被重写
        3.子类重写父类重的方法：那么方法的访问权限修饰符，子类的重写方法的修饰符大于父类的。

4.访问权限修饰符，费访问权限修饰符，static修饰符

5.继承比较重要

今日整理:
1.什么是继承?它有什么好处和坏处?
答：继承就是将子类中的共同属性（成员变量）和行为（成员方法）派生出一个新的父类，这个过程就是继承。
好处：1. 提高代码的复用性
          2. 便于代码后期的维护（在父类中修改属性和方法，子类不用修改）
坏处：父类和子类的代码耦合度很高。
2.两个类若是有继承关系,如何进行访问(变量和方法)?
答：根据访问的的优先级。根据就近原则，先访问局部变量，没有就访问成员变量，
没有就访问父类成员变量。方法访问优先访问本类的，没有就访问父类方法。
3.什么是方法的重写?它有什么需要注意的地方?
答：在子类中，定义一个和父类中一模一样的方法，这个操作就叫方法的重写。
1.怎么判断子类中的方法是否时重写的方法，可以使用注解@Override
如果编译没有报错，就是重写的方法，编译报错了，不是重写的方法
2.父类中私有的方法不能被重写
3.子类重写父类重的方法：那么方法的访问权限修饰符，子类的重写方法的修饰符大于父类的。
访问权限修饰符： public >= protected => 默认
4.今天讲了哪些修饰符?各有什么作用和特点?
答：public：  被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
protectd： 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
- 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
protected ：可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
默认的： 使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。
private：私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
final：它表示最终的意思，它可以修饰类，修饰方法，修饰变量
在实际开发中，通常使用final修饰变量，final修饰的变量时基本类型：表示基本类型的值不能修改了
final修饰的变量时引用类型：表示引用类型的地址值不能改变（引用类型的值可以改变）
static：它可以修饰成员变量，成员方法，代码块。凡是类中被static修饰的变量，代码快，只会初始化一次。
优点：提高代码的执行性能（效率）
5.聊聊今天你觉得重要的点.
答：继承的使用，权限修饰符的使用。

今日整理:
1.什么是继承?它有什么好处和坏处?
2.两个类若是有继承关系,如何进行访问(变量和方法)?
3.什么是方法的重写?它有什么需要注意的地方?
4.今天讲了哪些修饰符?各有什么作用和特点?
5.聊聊今天你觉得重要的点.

今日整理:
1.什么是继承?它有什么好处和坏处?
继承就是将子类中的共同属性（成员变量）和行为（成员方法）派生出一个新的父类，优点：复用性和可维护性。缺点：子类缺少独立性
2.两个类若是有继承关系,如何进行访问(变量和方法)?
extends  super
3.什么是方法的重写?它有什么需要注意的地方?
定义一个和父类一模一样的方法，注意：使用 “@Override” 检查重写；父类中私有的方法不能被重写；子类的重写方法的修饰符权限大于父类
4.今天讲了哪些修饰符?各有什么作用和特点?
访问修饰符：public；protected；默认；private
非访问修饰符：final；static
        final：修饰类，修饰方法，修饰变量；通常用来修饰变量----当变量是基本类型，基本类型的不能修改。当变量是引用类型，引用类型的地址不能改变。
        static：修饰成员变量，成员方法，代码块；凡是在类中被static修饰的变量，方法，代码块，只要被修饰只会初始化一次；加载配置文件，只加载一次
5.聊聊今天你觉得重要的点.
①继承不能继承多个父类，只能有一个父类。继承具有传递性
②使用 “@Override” 检查重写；父类中私有的方法不能被重写；子类的重写方法的修饰符权限大于父类
③重写保证子类方法的独立性
④如果子类和父类的方法重名了，使用super区分，创建子类对象时，默认调用父类的无参构造。
⑤package----管理--类，区分相同的类；import---用来确定在当前类里面使用的是哪个包下的类；简化包的书写；“*”为通用符
⑥final---通常用来修饰变量----当变量是基本类型，基本类型的不能修改。当变量是引用类型，引用类型的地址不能改变。
在父类中使用final---如果类被修饰，这个类不能被继承；如果类中的变量被修饰了，这个变量可以被继承，但不能被修改；如果类中的方法被修饰了，这个方法不能被继承，但可以调用
⑦static---修饰成员变量，成员方法，代码块；凡是在类中被static修饰的变量，方法，代码块，只要被修饰只会初始化一次；加载配置文件，只加载一次；优点：提高代码块的执行效率
静态变量和方法，以及普通变量和方法的使用范围
在普通方法里：直接使用静态变量和静态方法；直接使用非静态变量和非静态方法
在静态方法里：不能直接使用非静态变量和非静态方法；直接使用静态变量和静态方法
注意：调用静态方法和变量，可以使用对象调用，也可以直接用了类名来调用