this，static关键字，包，访问限定符，面向对象的四大特性

一.this 关键字

关键字this：this代表当前对象，主要在方法中使用（普通，构造），主要作用是为了区分全局变量和局部变量

哪个对象调用我这个方法，这个this就是谁

访问属性：对象名称.属性名
访问方法：对象名称.方法名();
实例化对象可以拿到类的默认值或初始值

public class Student {
  String name;//全局变量拥有默认值，局部变量没有默认值
  
  public Student() {//无参构造方法语法:访问限定符（public protected private 缺省）   类名（）{     }
   super();
   System.out.println("无参数构造方法");
   // TODO Auto-generated constructor stub
  }
  
  //有参构造方法，规定：形参的名字一般与全局变量的名字一致，为了区分使用this关键字
  //有参构造方法作用：实例化对象的时候给该对象的属性赋值，与类的属性无关
  public Student(String name) {//形参的作用：在方法中当作局部变量来使用，形参要想使用，要赋予一个值）
   System.out.println("有参数构造方法调用");
   //使用形式参数给全局变量赋值,this后的name是全局变量的name
   //this后的name 不是这个类的，是这个类实例化的对象的
   //对象是类的一个具体实例，对象是拥有自己的独特的一些属性值，而不是属性
   this.name=name;
  }
  
  public static void main(String[] args) {
   //实例化第一个student对象
   Student stu01=new Student("张三");//类名 对象名=new 类名();    实例化对象
   System.out.println(stu01.name);
   //实例化第二个student对象
   Student stu02=new Student();//类名 对象名=new 类名();    实例化对象
   System.out.println(stu02.name);
  }
}

this关键字在方法中可以当做一个实际的对象进行使用
Student stu =new Student() this = stu

//普通方法
  public void study() {
   System.out.println(this+"谁在学习");
   Student stu=this;//com.xingyun.Demo.Student@34c4973   引用这个
   System.out.println(this);
   this.eat();
  }
   public void eat() {
   System.out.println("我想吃薯片了");
  }

  //junit测试
  @Test
 void test() {
  //测试方法中的this关键字
    Student stu=new Student();
    System.out.println(stu);//输出stu的地址值com.xingyun.Demo.Student@bd8db5a
    stu.study();//com.xingyun.Demo.Student@bd8db5a谁在学习         this表对象
    System.out.println("-------------------");
    Student stu01=new Student();
    stu01.study();//com.xingyun.Demo.Student@52feb982谁在学习
 }
 @Test
 void test01() {
  //值传递与引用传递
    Student stu=new Student();
    System.out.println(stu.name);
    Student stu01=stu;
    stu01.name="张三";
    System.out.println(stu.name);
    int a=10;
    System.out.println(a);
    int b=a;
    b=20;
    System.out.println(a);
     }

二.static关键字

static可以修饰属性和方法，被static修饰的属性和方法属于类所有。
对象是根据类实例化来的
类是一个特殊的对象，静态属性会在堆内存中进行对应的创建，其他实例化对象要去拿到这个静态的属性的话，实例化对象它就会引用该类的静态属性值，并且多个对象会共享它们的属性值。一旦改变一个，那么整个都会改变。
1.static修饰属性
静态属性属于类所有，所有的实例化对象共享类的静态属性。一个对象对类的静态属性的修改会影响到其他类的引用值。

public class StudentStatic {
  String name;
  //静态属性，
  static int age=20;
  //无参构造
  public StudentStatic() {
   super();
   System.out.println("无参构造方法的使用");
   // TODO Auto-generated constructor stub
  }
  //有参构造
  public StudentStatic(String name) {
   super();
   this.name = name;
  }
//junit测试
@Test
 void test() {
  //静态方法的调用：类名.静态属性名           静态名.属性名
  System.out.println("修改之前"+StudentStatic.age);
  //对象来调，对象通过类得到
  StudentStatic stu =new StudentStatic();
  System.out.println(stu.age);
  stu.age=30;//修改对象的  但是这个age是static的，它是类的
  System.out.println("修改之后"+StudentStatic.age);
  System.out.println(stu.age);
 }
 @Test
 void test01() {
  StudentStatic stu01 =new StudentStatic();
  System.out.println(stu01.age);//20
  stu01.age=30;
  StudentStatic stu02 =new StudentStatic();
  System.out.println(stu02.age);//30
 }

静态方法只能调用静态方法，静态方法只能调用静态属性

public static void play() {
   System.out.println(age);//不能调用name，因为name是非静态的
  }

2.方法
静态方法属于类所用，调用的时候使用类名.方法名调用，也可以使用对象去调
静态方法（在工具类中使用 ,比如：日期格式化，字符串转换，数组排序，数据库连接 …）

//密码加密    参数：输入的密码123456     返回值：得到的加密结果：123456ABCD
  public static String md5(String pass) {//属于对象所有
   return (pass+"abcd").toUpperCase();
  }
  //junit测试
 @Test
 void test02() {
   //直接使用类去调用
  String md5=StudentStatic.md5("123456");
  System.out.println(md5);
  StudentStatic stu=new StudentStatic();//实例化对象
  String pass=stu.md5("123456");//传参
  System.out.println(pass);
 }

静态代码块
static{ }
静态代码块的作用：在程序的一次运行期间，只会被实例化一次，静态代码块也属于类所有（在类第一次被加载的时候调用）

三.包

1.包的命名规则
包的命名规则：域名后缀com cn +公司名+类型包（bean,entity,dao,imp,service,action,controller,util）

包名全部小写，多个单词之间使用.来进行分隔，并且在工作空间会生成一级一级的目录
com.xingyun.bean（com下xingyun下的bean包）
2.包的作用
包的作用：为了可以在项目中区分不同功能代码
类的全路径： 包名.类名
Java项目 src 资源包：在程序启动的时候 默认加载该资源在的文件
otherSrc 和src都是资源文件夹，它们里面的文件，都会进行编译，然后保存到bin包下
Demo com.xingyun.bean.Demo
Student com.xingyun.bean.Student 它们所在bean相同

不同包下的类 不能直接相互引用，要进行导包操作。
（1）使用import关键字 在类的package关键字之后

import com.xingyun.demo2.*；//代表导入该包的所有的类

（2）在要使用的类中demo2 ,使用demo1的全路径使用

com.xingyun.demo1.Demo1 demo1=new com.xingyun.demo1.Demo1();
demo01.test1();

四.访问限定符

访问限定符是用来修饰我们属性、方法、类 。使用不同的限定符会导致属性、方法在被调用的时候进行约束 。
public 公共 private 私有 protected 受保护 不写
使用修饰符来修饰属性和方法（ 一般类都使用 public修饰）

类只能用公共的或者默认修饰
同一个类

public class Car {
 //属性
 String name;//默认修饰，出了包不能直接用
 public double price;//公共属性，可以在任意地方使用
 private String color;//私有属性，只能在自己类中使用
 protected String type;//受保护的，不同包的非子类不能用
 ublic void test() {
  System.out.println(name);
  System.out.println(price);
  System.out.println(color);
  System.out.println(type);
 }
 public static void main(String[] args) {
  Car car=new Car();
  car.test();
 }
 
}

方法

属性 方法
同类中、同包、不同包的非子类
public 都可以使用
private 只能在本类中使用
默认 不同包的非子类不能使用
protected 不同包的非子类不能使用

修饰类（类、接口）：public、private、无（default）
public：公共的。在任何位置都能访问到这个类。
private：私有类，可作为内部类被所属的类访问，其他类无法访问。
default：只能被同一包下的类访问。
修饰属性和方法：public、protected、无（default）、private
public：任何位置都能访问，类或者该类的对象之间访问
protected：同一包中的类可以访问，子类中可以访问；若这些该类的对象在其他类（非同包类或子类）中，则该对象不能访问其protected属性和方法
defalut：不写修饰符时，是默认值。默认为在同一个包内可以访问，包外不能访问。private：只有当前类可以访问

五.面向对象的四大特性（三大特性）

最基本的特性(只有普通类) public class 修饰的类
(1) 抽象
将现实生活中的事物用java类来表示的一个过程(建类).
抽象是一种想法而已,不用过多关注.
(2) 封装
封装是对java类的属性的操作。前提：类的属性是使用private修饰的（私有属性）
私有属性只能在自己本类中进行使用.
在其他类中无法直接使用（其他类不管是在同一个包下还是在不同的包下都不能直接地进行调用，使用对象也不能调）.
为了不让别人直接能够去操作我的属性.
封装： 是将自己类的属性进行私有化,不让别的类直接使用自己的属性,对其私有属性使用public 的getter和setter方法对其进行封装.别的类在需要使用自己的属性是可以间接使用封装的方法来操作。保障自己的属性的私有性(安全性).
JavaBean显示的无参数构造方法 私有属性 封装的方法 toString方法

封装就是为了让别人能够使用我自己的私有化的属性。
在自己本类中提供一个可以用来操作私有属性的一个公共方法（用public修饰的方法）
公共方法一般有两个： 给私有属性赋值的方法set***、获取私有属性的方法get***

public class Student{
 //私有化属性,只能在本类中使用
 private String name;
 private int age;
 //进行封装
 //给私有属性赋值的方法  name是对象的name，我new的是student（）
 public void namefuzhi(String name) {
  this.name=name;//给实例化的属性赋值
 }
 //获取私有name属性的方法
 public String namequzhi() {
  return name;
  
 }
}
public class StudentTest {
 public static void main(String[] args) {
  Student stu=new Student();
  //System.out.println(stu.name);
  stu.namefuzhi("张三");
  System.out.println(stu.namequzhi());
 }
}

在java中 封装一般会给该类的所有所有私有属性进行封装，默认赋值使用set属性名（参数），属性名首字母大写，参数的类型与属性类型一致，参数的名字一般与属性名一致， 在方法中使用this来进行区分
获取属性的方法：返回值 get属性名(),属性名首字母大写, 返回值类型与属性类型一致,没有参数, 方法中使用return关键字 返回类的属性名

public class Student{
 //私有化属性,只能在本类中使用
 private String name;
 private int age;
 private boolean sex;//true男   false女
 //封装
 public void setName(String name) {
  this.name=name;
 }
 public String getName() {
  return name;
 }
 public void setSex(boolean sex) {
  this.sex=sex;
 }
 public boolean getSex() {
  return sex;
 }
 public void setAge(int age) {
  this.age=age;
 }
 public int getAge() {
  return.age;
 }

Eclipse会自动生成，私有属性封装方法的方式
封装快捷键：右键–>Sourse–>Generate Getters and Setters(Alt+Shift+S选择Generate Getters and Setters)

Eclipse自动创建的get方法 ，属性是boolean类型的，生成的是is属性名，要将is改为get（这是一种规定，不改也没有错，但尽量不要这样写）
Java 中有一个东西（类）JavaBean(EJB)
Java的实体类： 必须显示的写出无参数构造方 所有属性私有化 封装方法JavaBean 是一种JAVA语言写成的可重用组件

尽量使用toString方法

//打印输出，学生详细信息
 public void showStudent() {
   System.out.println("学生信息是：姓名"+this.name+"年龄"+this.age+"性别"+(sex?"男":"女")); 
 }
 //它是重写了object父类的方法，如果不重写，会默认调用object的String
 @Override
 public String toString() {
  return "Student [name=" + name + ", age=" + age + ", sex=" + (sex?"男":"女") + "]";
 }

(3)继承
将两个类建立关系，建立子父类关系，比如：A类和B类，A是子类，B是父类，使用关键字（extends）
继承： 使用关键字extends将java的类与类建立子父类关系
继承之后：子类和父类
一个类只能有一个直接父类 可以间接有多个父类
一个类可以有多个子类 多个子类之间没有关系
继承之后
子类拥有父类的 非私有属性和非final属性以及非私有方法
构造方法不能被继承
继承之后
子类可以有自己独有的方法和属性 子类也可以重写父类中的方法

class 类名 extends 父类类名{
    类中成员
}

继承的概念：
继承是面向对象的三大特征之一，子类可以直接使用父类的非私有成员。
父类也称为：基类，超类
子类也称之为：派生类
在多个类，具有部分相同的属性和行为的时候，可以将多个类的公共部分抽象抽来一个父类（就可减少代码量）

继承的特点：
a.Java中只能有单继承，一个类只能有一个直接父类，但是可以有多个间接父类

b.子类继承父类之后 就拥有了父类的非私有属性

c.final修饰的属性为最终属性,子类不能继承
final关键字：使用final修饰的变量叫常量，在程序运行中，值不可改变，在进行运算时，类型不会改变

d.子类可以拥有独有的属性

e.子类继承了父类，子类就拥有父类的非私有方法，子类也可以有自己独有方法

f.子类继承了父类,子类中有和父类一样的属性和方法

属性： name color
子类new子类 子类使用自己的属性

父类new父类 使用的是父类的属性

方法 ： 在子类中写了和父类一样的方法,包括返回值，方法名，参数的个数和类型
子类new子类 调用子类的方法

方法：在子类中写了和父类一样的方法,包括返回值，方法名，参数的个数和类型，顺序 叫重写。

重写：在子父类中 ，子类和父类的方法的名字，返回值，参数包括参数的个数、类型、顺序都全部一致 .可以使用 @Override 可以进行校验.
子类重写的方法可以使用final来修饰 ，子类重写的方法可以使用比父类方法的访问限定符更高权限去做，不能比它低，最低也要一样。@Override该注解表示校验该方法是不是重写父类的方法
父类的final方法不能被重写
最终方法不能被重写 （所谓的最终方法就是使用final关键字修饰的方法）

子类在继承父类之后,在实例化子类的时候,必须先实例化父类,默认会去调用父类的无参数构造方法 .
如果父类中没有无参数构造方法 ，可以使用super关键字来调用父类的其他构造方法，一个参数或者多个参数

Super 必须方法构造方法的第一行执行

属性和方法的调用 子类new子类
子类和父类有同样的属性 子类使用自己的属性
子类没有重写父类的方法 子类使用父类的方法(重写之后,使用自己的)
(4)多态 必须先有继承(实现)

父类引用指向子类对象（使用父类类型的变量来接收子类的实例对象）叫做多态
具体什么是多态： 一个对象在程序拥有两种状态：编译时状态、运行时状态
语法 ：

父类类型  名字 =new 子类类型();    
Animal  animal =new Mouse();  

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

l 多态成员方法

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

向上转型
实例化子类赋值给父类变量
向下转型 必须要先有向上转型

向上转型后的父类对象转为子类对象
向上转型之后，该对象在调用属性和方法的时候。特别注意它到底调的是父类的还是子类的，调属性全看父类，调方法看子类和父类的方法有没有重写（要调子类和父类都有的东西）

直接向下转
多态：是用父类来约束实际的调用。
向下转型：必须先有向上转型（强制转换）
将向上转型得到的对象再向下转型 。
使用instanceof关键字来判断该对象是不是那个类型的

多态是为了让我们在使用子父类(接口)的时候,可以用父类来约束子类的操作
所有对象的父类是Object

public class Test {
 public static void main(String[] args) {
  //谁继承了谁，谁就是个谁
  //Mouse extends Animal    Mouse就是个Animal
  Mouse mouse=new Mouse();
  System.out.println(mouse instanceof Object);//true
 }
}