day02 - Java的特性和接口

第一章 面向对象

1. 面向对象思想

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现（万物皆对象）

2. 面向对象特点

面向对象的语言中，包含了三大基本特征，即封装、继承和多态，还有抽象

3. 类与对象

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物
对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为
区别：
类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体
例：
人类是类，张三，李四，王五都是对象

4. 类与类的实例化

事物与类的对比
现实世界：属性：事物的状态信息 行为：事物能够做什么
Java：成员变量：对应事物的属性 成员方法：对应事物的行为
类定义

public class 类名 {
 //成员变量
//成员方法
}

类的实例化
创建对象

类名 对象名 = new 类名();

使用对象访问类中的成员:

对象名.成员变量名；
对象名.成员方法名()；

类与对象的练习：人类（姓名，年龄）
定义类

public class Person {
    private String name;
    private int age;
    public Person(){

    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"要吃饭！");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

测试

public class PersonTest {
    public static void main(String[] args) {
        //创建对象
        Person p =new Person("张三",22);
        p.eat();
        System.out.println(p);
        p.setAge(23);
        p.setName("李四");
        p.eat();
        System.out.println(p);
    }
}

结果：

张三要吃饭！
Person{name='张三', age=22}
李四要吃饭！
Person{name='李四', age=23}

第二章 封装

1. 封装概述与案例

通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口

1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、setXxx 方法

例：见上面的练习

2. 权限修饰符

访问控制符	访问权限	本类	本包中的其他类	子类	其他包中的其他类
Public	公开的	v	v	v	v
Protected	保护的	v	v	v	o
默认方式	默认的	v	v	o	o
private	私有的	v	o	o	o

同通常情况下所有的成员变量用private 修饰，所有的成员方法都用public 修饰
public修饰的内容表示可以在任意位置进行访问
private修饰的内容只能在本类中进行访问

3. this关键字与构造器

this的含义

• this代表所在类的当前对象的引用（地址值），即对象自己的引用
• 方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁

this使用格式

this.成员变量名；

例：见上面的练习

构造方法

构造方法的定义格式

修饰符 构造方法名(参数列表){
 // 方法体
}

• 如果不写构造方法，类中会默认生成一个无参的构造方法。如果写了一个有参的构造方法，则不会默认生成无参的构造方法了
• 如果写了有参构造方法，一般建议无参的构造方法也需要写上

例：见上面的练习

4. 标准代码 – JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法。
例：见上面的练习

第三章 继承

1. 继承概述与案例

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。JAVA 只支持单一继承（不支持多继承），JAVA 支持多层次继承（简称：多重继承）

好处 ：提高代码的复用性；类与类之间产生了关系，是多态的前提

2. 继承定义与super关键字

继承定义
通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {
 ...
 }
 class 子类 extends 父类 {
 ...
 }

super关键字
使用格式：

super.父类成员变量名

方法重写
子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆
盖效果，也称为重写或者复写。声明不变，重新实现。

例：

package com.example.demo;

public class Person {
    private String name;
    private int age;
    public Person(){

    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"要吃饭！");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.example.demo;

public class Student extends Person{
    private int sex;//性别
    public Student(){

    }

    public Student(String name, int age, int sex) {
        super(name, age);
        this.sex = sex;
    }
    @Override
    public void eat(){
        System.out.println(super.getName()+"要吃饭！");
    }
}

第四章 多态

多态是继封装、继承之后，面向对象的第三大特性。
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。简单的说，多态就是事物的多种形态

多态的格式：

父类类型 变量名 = new 子类对象；
变量名.方法名();

例：
继承同上

public class PersonTest {
    public static void main(String[] args) {
        Person p = new Student("王五",30,1);
        p.eat();//王五要吃饭！
    }
}

第五章 抽象类

1. 抽象类概述

Java语法规定，包含抽象方法的类就是抽象类
抽象方法 :没有方法体的方法
抽 象 类 :包含抽象方法的类

2. 抽象方法

使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：

修饰符 abstract 返回值类型 方法名 (参数列表);

代码举例：

public abstract void run()；

3. 抽象类

如果一个类包含抽象方法，那么该类必须是抽象类
定义格式：

abstract class 类名字 {
 }

代码举例：

public abstract class Animal {
 public int age;
 public abstract void run()；
}

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义

例：

public abstract class Person {
    private String name;
    private int age;
    public Person(){

    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name+"要吃饭！");
    }
    public abstract void work();

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Student extends Person{
    private int sex;//性别
    public Student(){

    }
    public Student(String name, int age, int sex) {
        super(name, age);
        this.sex = sex;
    }
    @Override
    public void eat(){
        System.out.println(super.getName()+"要吃饭！");
    }
    @Override
    public void work() {
        System.out.println("我要上学");
    }
}

4. 注意事项

• 抽象类不能被实例化，如果创建对象，编译无法通过会报错。只能创建其非抽象子类的对象

• 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的

• 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类

• 抽象类的子类，必须重写抽象父类中所有的抽象方法,否则编译无法通过而报错。除非该子类也是抽象类

第六章 接口

1. 接口概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）

定义格式

public interface 接口名称 {
 // 抽象方法
// 默认方法
// 静态方法
// 私有方法
}

• 接口不是类，也没有构造函数，接口成份中只有常量和抽象方法：
  • 常量：描述接口基本信息
  • 抽象方法需要类实现

2. 抽象方法，含有默认方法和静态方法，含有私有方法和私有静态方法

抽象方法：使用abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用
默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写
静态方法：使用static修饰，供接口直接调用
私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用
例：

public interface InterfaceAcc {
    public abstract void method();//抽象方法
    public default void method1(){//默认方法

    };
    public static void method2(){//静态方法

    };
    private  void method3();//私有方法
    private  static void method3();//私有静态方法
    
}

3. 接口的实现，多实现

接口实现格式

class 类名 implements 接口名 {
 // 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
}

接口多实现格式

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
 // 重写接口中抽象方法【必须】
// 重写接口中默认方法【不重名时可选】
}//[]可选

例：

public interface MyInterA {
 // 定义抽象方法
public abstract void method();
 }
 
 public interface MyInterB {
 // 定义抽象方法
public abstract void show();
 }
 
 //子类实现两个接口，接口之间使用逗号来分隔
public class Child implements MyInterA,MyInterB {
 	//重写MyInterA中的方法
	public abstract void method();
 	//重写MyInterB中的方法
	public abstract void show();
 }

4. 接口的多继承

类与类之间可以通过继承实现代码复用，接口间为了代码复用也是采用继承思想，并且可以实现多继承

interface   InterA{ 
public abstract void func ();
 }
 
 interface InterB {
 public abstract void method();
 }
 
 interface Interc extends InterA,InterB{
 }
 
 //实现类InterImpl，实现接口
class InterImpl implements Interc{
 //需要重写func方法 
public void func(){}
 //重写Interc接口中的方法 
public void method() {}
 }

5. 接口与抽象类的区别

• 接口可以多实现；而抽象类只能单一继承
• 接口中只能定义常量和抽象方法；而抽象类中除了可以定义抽象方法外，还可以定义构造、静态成员、普通成员
• 接口不能实例化(没有构造函数)；抽象类也不能实例化(具有构造函数[为子类对象初始提供服务])
• 接口是用来描述事物的扩展功能； 而抽象类是用来描述不清楚或不具体的事物

充实！！！