JAVA基础（三）

三、JAVA面向对象
Java是纯面向对象的。注重结果，调用的过程。面向对象思想。
C语言是面向过程的。注重步骤，实现的过程。
举例：吃饭，洗衣服。
1．类与对象
类 概念 看不见摸不着 抽象的
对象 实体 看得见摸得着 具体的
人类 和 武佳鹏
月饼模子 和 月饼

关系：
由众多具有相同特性的对象，抽象出的类。
由类具体实例化 等到 某一个对象。

1.声明定义类
public class Person{
//成员

//成员属性（变量）
String name;
int age=1;
double weight;

//成员方法
void eat(){
System.out.println(“吃饭饭”);
}
void drink(){
System.out.println(“喝奶奶”);
}

}

2.使用对象。
Person p1 = new Person();
System.out.println(p1);//com.srzx.demo.demo01.Person@29453f44
p1.eat();
p1.drink();
p1.name = “史真香”;
System.out.println(p1.name);

Person p2 = new Person();
System.out.println(p2);//com.srzx.demo.demo01.Person@5cad8086
System.out.println(p2.name);//null
p2.drink();

Java三(四)大特性：封装、继承、多态 (、抽象)
2．封装
举例：打包快递盒子。

数组是 对 相同类型的变量的封装
方法是 对 代码集合的封装
类 是 对 方法的封装
类 是 对 不同类型的变量的封装

（1）private关键字：私有的

私有化 成员属性
提供 公开的 get和set方法，用来 得到和设置成员属性

public class Person{
  private String name;

  public String getName(){
    return name;
  }

  public void setName(String name){
    this.name = name;
  }
}

快捷键： alt+shift +s 生成 get/set方法

（2）this关键字
this 指代 当前对象
this 在 成员方法中使用。

（3）构造方法
用途：给对象的属性 赋初值
特点： 构造方法的名字与类名一致，并且没有返回值。
声明定义：
public class Person{
private String name;

//无参构造方法
public Person(){

}
//有参构造方法
public Person(String name){
this.name = name;
}
}
public void Person(){}

调用时机：
Person p1 = new Person();
Person p2 = new Person(“齐德龙”);

构造方法重载：方法签名相同，参数列表不同（个数、顺序、类型）

（4）改写：学生信息管理系统
3．继承
class B
class A extends B

A 子类 子类 派生类
B 父类 超类super 基类

继承具有传递性
class C extends A
C也同时具有 A 和 B 的特性

Java中类的继承 是单继承，但提供了多继承的机制，叫多实现。
接口的继承是多继承。

（1）super关键字

构造方法不会被继承，即使 修饰符是 public。

子类的构造器 第一句 默认 调用父类的无参构造器，可也不写 super();
子类的构造器，调用父类的有参构造器，需要写super(123,456);
要使用父类的构造器的话，必须是 在 子类构造器的第一句。

在子类方法中，调用父类的方法，可以使用 super.drink(); super代表的时父类的对象。

（2）访问限制修饰符
本类 同包 子类 异包
private √ × × ×
(default) √ √ × ×
protected √ √ √ ×
public √ √ √ √

（3）方法的重写
重载 一个类中的方法 方法签名相同 参数不同 与返回类型无关 修改方法体
重写@Override 父子类之间方法 方法签名相同 参数相同 返回类型要一致 修改方法体

重写：父类方法满足不了子类的需要，子类将其改写。要求方法签名要和父类一致，只能改写 方法体。需要@Override来检查。

4．多态
（1）抽象方法
public void eat(){

}

public abstract void eat();

一个方法，没有方法体，连方法体的大括号，这个方法 是抽象方法，需要使用关键字 abstract来修饰。

（2）抽象类
抽象方法所在的类，叫做 抽象类，也需要关键 abstract修饰
public abstract class Animal{
public abstract void eat();
}

子类继承父类，父类是抽象类，要求 子类 要么 去 实现(重写) 父类的抽象方法，要么 将子类 也标记为 抽象类。

抽象类不能实例化，不能得到对象了。
//Animal animal = new Animal();

如果非要 实例化，需要将所有抽象方法 实现了。

 Animal animal = new Animal() {
            @Override
            public void eat() {

            }
            @Override
            public void drink() {

            }
        };

抽象方法所在的类，叫做 抽象类。
抽象类中一定有抽象方法吗？不一定。也可以普通方法、属性。

抽象类的作用：制定规范，宏伟蓝图，装修设计图、架构(师)

（3）接口
接口是一种特殊的抽象类。在接口中 所有的方法 都是抽象方法，所有属性都是常量。

定义接口
public interface USB {
int v = 5;//电压
public abstract void power();
public void transferData();
}
实现接口
public class Mouse implements USB{
@Override
public void power() {
System.out.println(“鼠标炫彩灯”);
}
@Override
public void transferData() {
System.out.println(“按键和光标”);
}
}

接口是一种能力。可以拥有多种能力。多实现

public class Computer implements USB,GPU,Music{
    @Override
    public void show() {

    }
    @Override
    public void play() {

    }
    @Override
    public void power() {

    }
    @Override
    public void transferData() {

    }
}

接口是多继承。
public interface IronManable extends Powerable,Flyable{

}

实现 感觉 和 继承差不多
继承 是 is a 是一个，狗继承动物，狗是一个动物。
实现 是 like a 像一个，电脑实现USB，电脑像一个USB。

先继承后实现

public class DellComputer extends  Computer implements LongUse,USB{
    @Override
    public void showLogo() {

    }
    @Override
    public void use() {

    }
}

多态：多种状态。同一种事件，对不同的事物，产生不同的结果。
多态的前提 是 必须要有继承（实现）。

向上转型：将子类转换为父类
父类变量 引用 子类对象
Class Client extends User{}
User user01 = new Client();

子类继承父类，用 向上转型 将 子类 转成 父类，调用时 父类的对象 调用，但 实质是 还是执行的子类 对象。

子类特有的方法，父类没有，父类对象 调用不到。
子类重写过 父类的方法，父类对象 调用 ，执行的是 子类 重写的方法。
子类没有重写父类的方法，父类对象 调用 的 就是 父类的方法。

向下转型: 将父类转成子类 ： 子类 子类变量 = (子类) 父类对象。强转。
User user01 = new Client();
User user03 = new Boss(“zhangan”,“123123”,“张三”);

Boss boss01 = (Boss) user03;
//java.lang.ClassCastException 类型转换异常
Boss boss02 = (Boss) user01;

（4）instanceof

对象 instanceof 类名 ： 判断 对象 是否是 该类的 实例

 if(user01 instanceof Boss){
     System.out.println("user01是Boss的实例");
 }

 if(user01 instanceof Client){
      System.out.println("user01是Client的实例");
  }

案例1：喂养宠物
案例2：打怪兽
5．关键字static
static 静态的,属于类。
如果修饰的是变量的，只初始化一次。静态变量，类变量。
调用时，建议使用 类名.变量名。 当然 可以 使用 对象.变量名。
public class Duck {

private static int number;
private String color;
public Duck() {
    number++;
}
public Duck(String color) {
    number++;
    this.color = color;
}
public static void main(String[] args) {
    Duck duck1 = new Duck("黄色");
    Duck duck2 = new Duck("绿色");
    Duck duck3 = new Duck("红色");
    Duck duck4 = new Duck("花的");
    //System.out.println(duck1.number);
    //System.out.println(duck2.number);
    //System.out.println(duck3.number);
    System.out.println(Duck.number);
}

}

如果修饰的是方法的，静态方法，类方法。
注意： 静态方法 不能 去 直接 使用 任何 对象的东西，比如 成员属性，成员方法，this关键字 更不能使用。
因为：静态方法(类方法)，是属于类的，而 类和对象的代码关系中，是先有类的。此时,可以没有对象，而直接 使用 类名.方法名(),调用静态方法。但是没有对象，不知道成员属性和成员方法的执行主体（对象）。

静态方法 不能使用成员（属性和方法），成员方法 可以使用 静态（属性和方法）。

public class Duck{
    public static void sum(){

    }

 Public static void main(String[] args){
       Duck.sum();
       sum();
   }
}     

6．局部变量、成员变量、静态变量
局部变量(形式参数) 成员变量 静态变量
声明定义 类型 变量名 修饰符 类型 变量名 加static关键字
写的位置 方法内 类内 类内
是否需要赋初值 必须要初始化 可以不初始化，系统自动赋值
0,0.0,’\u0000’,false
null 可以不初始化，系统自动赋值
同左
作用域 离声明定义最近的大括号内 有对象的地方 有类的地方
生命周期 {}的范围内，执行完销毁 对象的生命周期
Person p = new Person();

p = null; 类的生命周期

7．成员方法、静态方法
构造方法 也是成员方法 成员方法 静态方法
声明定义 public 类名(){} 修饰符 返回值类 方法名(参数列表){} 修饰符 static 返回值类 方法名(参数列表){}
作用 初始化对象 对象的方法，对象的功能、行为、动作 类的方法、工具方法
调用 new 类名() p.eat() Person.eat()
不能随便调用 成员方法可以调用 静态方法 静态方法 不能调 成员方法和成员属性。