第一阶段 javaSE 面向对象 02

封装详解

我们程序设计要追求“高内聚、低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合：仅暴露少量的方法给外部使用
封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
记住这句话就够了：属性私有，get/set（用private来修饰属性，外部无法直接调用和修改属性值，只能通过set和get方法，可以通过set方法作一些安全性验证的判断，外部无法查看具体实现，体现了封装）

public class Student {
    //属性私有
    private String name;
    private int age;
    private int id;

    // 属性私有需要提供一些可以操作这个属性的方法
    //提供一些public的get、set方法
    //通过快捷键Alt+insert 选择getter and setter插入方法

    //get获得这个数据
    public String getName() {
        return name;
    }

    //set给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

封装的好处：

提高程序的安全性，保护数据
隐藏代码的实现细节
统一接口
系统可维护性增加了

什么是继承

继承的本质是对某一类的抽象，从而实现对显示世界的建模
extends的意思是“扩展”，子类是父类的扩展
java中类只有单继承，没有多继承（一个子类只能继承一个父类，一个父类可以由多个子类，但子类同样可以实现父类的父类的方法）
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等

继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键词extends来表示

子类和父类之间，从意义上讲应该具有"is a"的关系

在父类中，public修饰的方法和属性可以直接被继承，若要用private修饰属性，需提供set和get方法

Java中的四个修饰符号。

private 仅对本类可见，无法被继承。
protected 对本包和所有子类（包括不在同一个包下的子类）可见。
默认（未声明任何修饰符）对本包可见。
public 对所有的都可见。

快捷键：ctrl+h可以查看此类的继承树

Object类

在java中，所有的类，都默认直接或者间接继承object类

super

super注意点：

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或构造方法中，目的是在子类中调用父类相关，子类默认调用了父类的无参构造，父类有参构造需要显示调用，若只重写有参构造，无参构造默认没有了，子类的无参构造也不能调用，只能调用有参
super和this不能同时调用构造方法，原因是构造方法只能出现在第一行，否则会保存，所以二者只能出现一个

super和this的区别：

代表对象的不同：

this：本身调用者这个对象

super：代表父类对象的引用

前提：

this：没有继承也可以使用

super：只能在继承条件下才可以使用

构造方法：

this()：本类的构造；

super()：父类的构造

方法的重写

A a = new A();
a.test();

//父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.test();

静态方法和非静态方法的区别很大：

静态方法：方法的调用只和左边，定义的数据类型有关

非静态方法：实现了子类对父类方法的重写

子类和父类方法都被public修饰时，可以重写方法，子类和父类方法都被private修饰时，不可以重写方法

重写小结：需要有继承关系，子类重写父类的方法

方法名必须相同
参数列表必须相同
修饰符，范围可以扩大但不能缩小，public>protected>default>private
抛出的异常：范围可以被缩小，但不能扩大：Exception(大) ----> ClassNotFoundException(小)

为什么要重写：

父类的功能，子类不一定需要，或者不一定满足

快捷键：Alt + insert ：override

什么是多态

动态编译：类型只有在编译的时候才能被确定

即同一个方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

多态存在的条件：有继承关系，子类重写父类方法，父类引用指向子类对象

注意：多态是方法的多态，属性没有多态性

在调用方法时，子类可以调用父类的方法和本类独有的方法，当父类引用指向子类对象时，此对象可以调用父类的方法，但如果父类方法被子类重写，此对象实现的是子类的方法，如果不进行类型转换，此对象不能调用子类独有的方法

//一个对象的实际类型是确定的
//如：new Student() , new Person()

//但可以指向的引用类型就不确定了，父类的引用可以指向子类对象
Student s1 = new Student();
//Person父类，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();

//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
s2.run();//子类重写了父类的方法，执行子类的方法

多态的注意事项：

多态是方法的多态，属性没有多态
需要是继承关系，即父类和子类的关系，否则或出现类型转换异常：ClassCastException
存在条件：继承关系，方法需要重写，父类引用指向子类对象：Father f1 = new Son();

无法重写的方法：

static修饰的方法：方法属于类，不属于实例

final 修饰的方法

private修饰的方法

System.out.println(X instanceof Y);//能不能编译通过的原因是X和Y之间有没有父子关系，或者X指向的实际类型是不是Y的子类型

//Object>Person>Student 
  Object obj = new Student();

  System.out.println(obj instanceof Student); //true
  System.out.println(obj instanceof Person);//true
  System.out.println(obj instanceof Object);//true
  System.out.println(obj instanceof String);//false
 
  Person person = new Student();
  System.out.println(person instanceof Student);//true
  System.out.println(person instanceof Person);//true
  System.out.println(person instanceof Object);//true
//  System.out.println(person instanceof String); 编译报错

类型之间的转化：八大基本数据类型从高向低转需要强制转换，从低像高转可以直接转换，引用类型的转换，将父类转换为子类需要强制转换，然后才可以调用子类独有的方法，子类转换为父类可以直接转换，但可能会造成方法丢失

Person obj = new Student();

//Student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
((Student) obj).go();

类型转换：

是父类引用指向子类的对象
把子类转换成父类，向上转型
把父类转换成子类，向下转型，需要强制转换
多态和类型转换都是为了方便方法的调用，减少重复的代码，简洁

封装，继承，多态都体现了java抽象的特征

static关键字

public class Person {
    /*
    * 执行的先后顺序：静态代码块，匿名代码块，构造方法
    */
    //1.只执行一次，在类加载的时候执行
   static{
        System.out.println("静态代码块");
   }
   //2.在对象创建的时候就执行，但在构造器之前
    {
        System.out.println("匿名构造器");
    }
    //3.构造方法
    public Person(){
        System.out.println("构造方法");
    }
}

抽象类

abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类，那么该类就是抽象类
抽象类中可以没有抽象方法，可以有普通方法，但是有抽象方法的类一定要声明为抽象类
抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，没有方法体，它是用来让子类实现的
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。

public abstract class Action {
    public abstract void doSomething();
}

抽象类是一个约束，可以把部分方法抽象出来，节省代码

接口的定义和实现

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有

接口：只有规范，自己无法写方法，使约束和实现分离

接口就是规范，定义的是一组规则

接口的本质是契约

00的精髓，是对对象的抽象，最能体现这一点的就是接口

声明类的关键字是class，声明接口的关键字是interface

public interface UserService {
    //接口中定义的属性都默认为常量 public static final
    //接口中一般只定义方法
    int AGE =99;

    //接口中的所有定义的方法其实都是抽象的 public abstract
    void add();
    void delete(int id);
}

public interface TimeService {
    void timer();
}

//接口的实现类可以实现多个接口，简单理解为多继承
//由于接口中全是抽象方法，故接口的实现类必须重写接口中的全部方法
public class UserSerivceImpl implements UserService,TimeService{ //实现类的名称一般是接口的名字后加Impl
    @Override
    public void add() {

    }

    @Override
    public void delete(int id) {

    }

    @Override
    public void timer() {

    }
}

接口的作用：是为了抽象的定义一些方法，约束不同的人实现

普通类，抽象类，接口的对比分析：

普通类和抽象类的继承都有extends，接口的继承用implements

抽象类class前用abstract修饰，接口不用class，而用interface

普通类的方法需要自己实现，抽象类可以由具体实现也可以有抽象方法，抽象方法用abstract修饰，接口中全部都是抽象方法，默认可以不用abstract修饰，继承抽象类的子类需要重写抽象类的所以抽象方法，继承接口的子类需要重写接口的全部方法

普通类和抽象类都不能多继承，但接口可以

普通类必须有构造方法，可以实例化，抽象类可以有构造方法，不能被实例化，接口没有构造方法，不能被实例化

内部类（了解）

内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就成为内部类，而A类相对B类来说就是外部类了（内部类可以调用外部类的private变量和方法）

一个java文件可以有多个class并列，但只能有一个public class

成员内部类（在类中定义的类）
静态内部类（在类中用static修饰的类，此时内部类不能方位外部类非静态属性和方法，因为时间片不同）
局部内部类（在类的方法中定义的类）
匿名内部类（没有名字初始化类，不用将实例保存到变量中，接口同理）

public class Test {
    public static void main(String[] args) {
        //匿名内部类
        new Apple().eat();
        //匿名接口
        new UserService1(){

            @Override
            public void hello() {
                
            }
        };
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService1{
    void hello();
}

posted @ 2022-05-17 10:06 封闭货车阅读(18) 评论(0) 收藏举报

刷新页面返回顶部

cigarette-lighter