JAVA---面向对象小结

一、封装

1.1 如何定义一个类

public class 类名{    

        //成员变量    //成员方法    //构造方法     // 代码块    // 内部类

}    

// 注意类名要符合 第一个字母大写后面每个单词首字母大写。

        public class Dog{   

                String name;   

                int age;   

                public void load(){      

                        System.out.println("汪汪汪")   

                }

        }

1.2 使用类创建对象

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

Dog dog = new Dog();

// 使用成员

// 对象名.属性名 =  对象名.方法名()

dog.name = "大黄";

dog.load();

1.3 封装概念

什么是封装

• 隐藏实现细节，提供公共的访问方式

怎么隐藏实现细节

• private,私有的，隐藏成员变量。合理隐藏
• 需要提供 set/get方法，公共访问方式，合理暴露

1.4 构造方法

作用

• 初始化对象用的，主要是初始化成员变量

特点

• 1、方法名和类名一样
• 2、没有返回值，连void都没有

注意事项

• 1、所有类都有构造，默认的构造是空参
• 2、我们写了构造，默认的构造就没了
• 3、开发建议空参和满参都写上

1.5 this关键字

1、this代表当前对象的引用

• 作用：用来区分成员变量和局部变量
• this只能存在于非静态方法中
• 谁调用这个方法，this就是谁

2、面试题

• 在一个静态方法中，不能有this关键字

1.6 JavaBean实体类

标准的类---JavaBean

public class Dog{

   private String name;

   private int age;

   public Dog(){}

   public Dog(String name,int age){  this.name = name;   this.age = age; }

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

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

   public String getName(){ return name; }

   public int getAge(){  return age; }

   public void load(){ System.out.println("汪汪汪")}

}

二、继承

2.1 继承基本概念

概念

• 让类与类之间产生父子关系，子类自动拥有父类中定义的属性和方法

格式

• class 子类名 extends 父类名{ }

例子

• class Cat extends Animal{ }

2.2 继承中成员访问特点

就近原则

• 1、变量先从局部位置找，找不到就去当前类的成员位置找，再找不到就去父类成员位置找，再找不到就报错
• 2、方法先从本类找，本类找不到去父类找，父类中找不到就报错

this.访问本类成员，super.访问父类成员

子类构造器默认第一行是super(); 代表先完成父类成员初始化再完成子类成员初始化

2.3 方法的重写

概念

• 在子类中出现了父类方法声明一模一样的方法，这种现象称为方法的重写，也叫覆盖。
• 重写通过子类对象调用，调用的是子类的

注意

• 私有的方法不能重写，静态方法不存在重写
• 子类重写的访问权限要大于父类的访问权限

2.4 权限大小关系

public  >  protected  >  默认  >  private

公共的  >  本包其他包子类  >  本包  >  本类

2.5 抽象

关键字：abstract

• 修饰方法，修饰类
• 修饰方法的特点

• public abstract 返回值类型 方法名(形参列表);

• 没有方法体，被abstract修饰，表示没有具体的实现方法

• 修饰的类，叫抽象类

• 特点：

• public abstract class 类名{ }

• 被abstract修饰的类，不能直接创建对象，可以有抽象方法和非抽象方法

抽象类不能直接创建对象，一般作为父类出现，需要子类进行继承，重写抽象方法

抽象类的应用---模板方法设计模式：

• 解决了什么问题？

• 提取了重复代码，提高代码复用性

• 怎么去完成的？

• 定义一个类---抽象类

• 类里包含两个方法

• 模板方法

• 共性代码

• 有不一样的代码，提取成抽象调用

• 抽象方法

• 声明不同代码实现的功能

2.6 接口

定义

• 用于定义规范，称为接口。特殊的文件结构里面存放抽象方法和常量
• 接口就是一些功能(方法)的集合。只定义了抽象方法。只有功能的声明，没有功能的实现

定义关键字

• interface
• 接口既然方法的集合，那么这些方法必然要被实现，需要具体的类去实现，实现关键字是implements。一旦一个类实现了接口，就要重写所有抽象方法

接口的内容

• 成员变量

• 常量    public static final

• 成员方法

• 初代   public abstract 抽象的

• JDK8 允许有默认的和静态的

• JDK9允许有私有的

2.7 接口和接口，类和类，接口和接口的关系

类与类之间是继承关系，支持单继承，不支持多继承，但是支持多层继承

类与接口之间是实现关系v，可以单实现也可以多实现

接口与接口之间，是继承关系，可以单继承，也可以多继承

三、多态

3.1 多态的概念

自然界中，一种事务，多种形态

java中，一个对象拥有另外的形态

• 示例： Lv lv = new Lv();  Animal a = new Lv();

3.2 多态的前提

一般有继承或者实现

一般会进行方法的重写

父类引用指向子类对象

3.3 多态的转型

向上转型（自动类型转换）

• 父类类型 fu = new 子类对象();

向下转型（强制类型转换）

• 子类类型 zi = (子类类型)fu;

3.4 多态成员访问特点(注意)

编译看左边，检查语法错误

运行看右边，真正的对象是谁

结论：成员变量（会被加载）访问看左边，成员方法访问看右边

3.5 多态的好处

提高了扩展性和灵活性

feedAnimal(Animal a) // 传递的都是地址值

好处：可以解耦合，接收所有子类对象，提高代码复用性

坏处：不能直接调用子类独有的方法

3.6 对象类型判断语法

对象名 instanceof 指定类型

结果是布尔类型，表示该对象是不是指定类型的对象，是就返回true 不是就返回false

四、其他知识点

4.1 final关键字

含义：最终的

可以修饰 类 --- 最终类  不能被继承

可以修饰方法 --- 最终方法 可以被继承不能被重写

修饰变量 --- 变成变量  只能赋值一次

注意： 基本类型数值不能变，引用类型， 地址值不能变

4.2 static关键字

含义：静态的，与类相关的

• 可以修饰成员变量、成员方法和代码块

特点

• 内存上

• 静态成员变量随着类的加载而加载，只加载一次，优先对象出现

• 使用上

• 直接通过类名调用

• 静态只能访问静态

4.3 abstract不能和final、static一起使用没有意义

4.4 内部类

含义

• 在一类中定义了另外一个类
• 类A定义了类B，类B就是类A的内部类

按照位置分为

• 成员内部类

• 普通成员内部类

• 外部类名.内部类名  变量名  =  new 外部类名(形参列表).new 内部类名(形参列表);

• 静态成员内部类

• 外部类名.内部类名  变量名  =  new  外部类名.内部类名(形参列表);

• 局部内部类

• 只能在局部位置使用

访问特点

• 内部类可以直接访问外部类成员
• 想要访问内部类成员，需要先new外部类对象，再new内部类对象

生成的类是有.class文件的

4.5 代码块

属于类的成分之一，定义在方法外，以{ }形式出现

static 静态代码块

• 随着类的加载执行一次

不加static修饰的是实例代码块

• 构造方法调用一次，在构造之前执行一次

4.6 匿名内部类

本质

• 是一个快速构建实现接口或者继承一个类的子类对象

格式

• new  接口/类(){ 重写方法 }

现象

• 在代码上生成了一个没有名字的类.class文件

使用场景

• 当方法参数是一个父类或者是一个接口的时候，且需要重写方法不多，可以使用匿名内部类代表其子类对象