Java面向对象OOP（下）

4、面向对象三大特性

封装

1. 程序设计追求”高内聚，低耦合“。
   高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
   低耦合：仅暴露少量的方法给外部使用

2. 封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住一句话：属性私有，get/set

package OOP_2;
/*
1、提高程序的安全性，保护数据
2、隐藏代码的实现细节
3、统一接口get、set
4、系统可维护性增加了
 */

public class Application {
    
    
    public static void main(String[] args) {
    
    
        Student s1 = new Student();
        s1.setName("xiaosan");
        System.out.println(s1.getName());

        s1.setAge(150);
        System.out.println(s1.getAge());

    }
}

package OOP_2;
//类    private:私有
public class Student {
    
    

    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;

    //提供一些可以操作这些属性的方法
    //提供一些public 的get、set方法

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

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

    public int getAge() {
    
    
        return age;
    }

    public void setAge(int age) {
    
    
        if (age > 120 || age < 0){
    
    //不合法
            this.age = 3;
        }else {
    
    
            this.age = age;
        }
    }
    //学习()
    //睡觉()
}

继承

1. 继承的本质是对某一批类的继承。extends的意思是扩展，子类是父类的扩展。
   继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示。
   子类和父类之间具有”is a“的关系

2. Java中只有单继承，没有多继承。

3. 继承是类和类之间的一种关系。除此之外，类和类之间还有依赖、组合、聚合等关系。

4. object类

5. super

Application

扫描二维码关注公众号，回复： 12254151 查看本文章

package OOP_3jicheng;

public class Application {
    
    
    public static void main(String[] args) {
    
    
        //
        //Student xiaowang = new Student();
        //xiaowang.say();

        Student student = new Student();
        //student.test("小张");
        //student.test1();
    }
}

Person

package OOP_3jicheng;

//在Java中，所有的类，都默认直接或间接继承object
//Person    人：父类
public class Person {
    
    
    //public
    //protected
    //default
    //private
    private int money = 10_0000_0000;
    public Person(){
    
    
        System.out.println("Person无参执行了");
    }

    public void say(){
    
    
        System.out.println("说了一句话");
    }

    public int getMoney() {
    
    
        return money;
    }
    
    public void setMoney(int money) {
    
    
        this.money = money;
    }

    protected String name = "xiaozhang";

    public void print(){
    
    
        System.out.println("ren");
    }
}

Student

package OOP_3jicheng;
//学生   is   人：  派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{
    
    
    public Student(){
    
    
        //隐藏代码：调用了父类的无参构造
        //super();//调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }

    private String name = "zhangjianlin";

    public void print(){
    
    
        System.out.println("Student");
    }

    public void test(String name){
    
    
        System.out.println(name);//小张
        System.out.println(this.name);//zhangjianlin
        System.out.println(super.name);//xiaozhang
    }

    public void test1(){
    
    
        print();//Student
        this.print();//Student
        super.print();//ren
    }
}

笔记

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中！
3. super和this不能同时调用构造方法！

Vs this:
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的引用
前提：
this：没有继承也可以使用
super：只有继承条件下才可以使用
构造方法：
this：本类的构造
super：父类的构造

6. 方法重写：重点-------->多态

Application

package OOP_4Dduotai;

public class Application {
    
    
    public static void main(String[] args) {
    
    

        //静态的方法和非静态的方法区别很大！
            //静态方法：方法的调用只和左边，定义的数据类型有关
            //非静态方法：
        A a = new A();
        a.test();//A

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

运行结果：
A=>test()
A=>test()

A

package OOP_4Dduotai;

//继承
public class A extends B {
    
    
//    public static void test(){
    
    
//        System.out.println("A=>test()");
//    }

    //Override   重写
    @Override //注解：有功能的注释！
    public void test() {
    
    
        System.out.println("A=>test()");
    }
}

B

package OOP_4Dduotai;

//重写都是方法的重写，和属性无关
public class B {
    
    
    public void test(){
    
    
        System.out.println("B=>test()");
    }
}

重写笔记

1. 重写需要有继承关系，子类重写父类的方法。
2. 方法名、参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小： public > protected > default > private
4. 抛出的异常：范围 可以被缩小，但不能扩大 ClassNotFoundException --> Exception（大）
   总之：所谓重写，子类的方法和父类必须一致，方法体不同。
5. 为什么需要重写：
   1）父类的功能，子类不一定需要，或者不一定满足！
   Alt + Insert: override
   Generate---->Override methods---->OK

多态

package OOP_4Dduotai;

public class Application_1 {
    
    
    public static void main(String[] args) {
    
    
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了：父类的引用指向子类

        //Student能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

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

package OOP_4Dduotai;

public class Person {
    
    

    public void run(){
    
    
        //
        System.out.println("run");
    }
}

package OOP_4Dduotai;

public class Student extends Person{
    
    

    @Override
    public void run() {
    
    
        System.out.println("son");
    }
    public void eat(){
    
    
        System.out.println("eat");
    }

}

多态注意事项：

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常！ ClassCastException !
   一个对象的实际类型是确定的，但指向对象的引用类型可以有很多（如父类、有关系的类）
3. 存在条件： 继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son( );
4. 不能重写的方法：
   1）static方法，属于类，它不属于实例
   2）final常量；
   3）private方法；

instanceof （类型转换）引用类型，判断一个对象是什么类型

5. static关键字

public class Static {
    
    
    //2：赋初值
    {
    
    
        System.out.println("匿名代码块");
    }
    //1：只执行一次
    static {
    
    
        System.out.println("静态代码块");
    }
    //3
    public Static(){
    
    
        System.out.println("构造方法");
    }
    public static void main(String[] args) {
    
    
        Static aStatic = new Static();
        System.out.println("===============");
        Static aStatic1 = new Static();
    }
}
/*
静态代码块
匿名代码块
构造方法
===============
匿名代码块
构造方法
 */

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Static_1 {
    
    
    public static void main(String[] args) {
    
    
        //
        System.out.println(random());
        System.out.println(PI);
    }
}

5、抽象类和接口

抽象类和接口的对比

抽象类是用来捕捉子类的通用特性的。接口是抽象方法的集合。
从设计层面来说，抽象类是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
相同点

• 接口和抽象类都不能实例化
• 都位于继承的顶端，用于被其他实现或继承
• 都包含抽象方法，其子类都必须覆写这些抽象方法

不同点

参数	抽象类	接口
声明	抽象类使用abstract关键字声明	接口使用interface关键字声明
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现	子类使用implements关键字来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
访问修饰符	抽象类中的方法可以是任意访问修饰符	接口方法默认修饰符是public。并且不允许定义为 private 或者 protected
多继承	一个类最多只能继承一个抽象类	一个类可以实现多个接口
字段声明	抽象类的字段声明可以是任意的	接口的字段默认都是 static 和 final 的

普通类和抽象类的区别

• 普通类不能包含抽象方法，抽象类可以包含抽象方法。
• 抽象类不能直接实例化，普通类可以直接实例化。

抽象类

//abstract关键字    表示抽象类   类只有单继承，接口可以有多继承
public abstract class Action {
    
    

    //约束，有人帮我们实现。
    //abstract,抽象方法，只有方法名字，没有方法的实现！
    public abstract void dosomething();

    //1.不能new这个抽象类，只能靠子类去实现它：约束！
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
}

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法，专业的约束！约束和实现分离：面向接口编程~

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

package Interface;

//抽象的思维
//interface  定义的关键字  接口都需要有实现类
public interface UserService {
    
    

    //常量
    public static final int AGE = 99;

    //接口中的所有定义的方法其实都是抽象的 public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);

}

package Interface;

public interface TimeService {
    
    
    void timer();
}

package Interface;
//通过这个类  实现接口  implements
//实现了接口的类，就需要重写接口中的方法

//implements UserService,TimeService
//多继承     利用接口实现多继承
public class UserServiceImp1 implements UserService,TimeService {
    
    
    @Override
    public void add(String name) {
    
    

    }

    @Override
    public void delete(String name) {
    
    

    }

    @Override
    public void update(String name) {
    
    

    }

    @Override
    public void query(String name) {
    
    

    }

    @Override
    public void timer() {
    
    

    }
}

作用：

1. 约束
2. 定义一些方法，让不同的人实现
3. public abstract 方法
4. public static final 常量
5. 接口不能被实例化，接口中没有构造方法
6. 通过implements实现，可以实现多个接口————即必须重写接口中的方法

6、内部类及OOP实战

内部类就是在一个类的内部再定义一个类。比如在A类中定义了一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

1.成员内部类

package neibulei;

public class Outer {
    
    
    private int id = 10;
    public void out(){
    
    
        System.out.println("这是外部类的方法");
    }
    class Inner{
    
    
        //
        public void in(){
    
    
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
    
    
            System.out.println(id);
        }
    }
}

package neibulei;

public class Application {
    
    
    public static void main(String[] args) {
    
    
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

2.静态内部类

3.局部内部类

package neibulei;

public class Outer_1 {
    
    

    //局部内部类:方法中定义类
    public void method(){
    
    
        class Inner{
    
    
            public void in(){
    
    
                //
            }
        }
    }
}

4.匿名内部类

package neibulei;

public class Outer_2 {
    
    
    public static void main(String[] args) {
    
    
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
        UserService userService = new UserService(){
    
    

            @Override
            public void hello() {
    
    

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

7、异常

1.什么是异常

1. 软件程序在运行过程中遇到的问题，我们叫做异常。英文是：Exception，意思是例外
2. 3种类型的异常：
   1）检查性异常：用户错误或问题引起的异常，程序员无法预见。比如：打开一个不存在文件时
   2）运行时异常：可能被程序员避免
   3）错误ERROR：不是异常，错误在代码中通常被忽略。比如：当栈溢出时，一个错误就发生了，编译时检查不到。

2.异常体系结构

3.Java异常处理机制

4.处理异常

抛出异常
捕获异常

异常处理五个关键字：try、catch、finally、throw、throws

package exception;

public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
        //
        int a = 1;
        int b = 0;

        //要点1：假设要捕获多个异常，从小到大！

        try {
    
    //try监控区域
            System.out.println(a/b);
        }catch (Error e){
    
    //catch(想要捕获的异常类型！) 捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }catch (Exception e){
    
    
            System.out.println("Exception");
        }catch (Throwable t){
    
    
            System.out.println("Throwable");
        } finally {
    
    //处理善后工作
            System.out.println("finally");
        }
        //finally 可以不要   假设IO，资源，关闭

        //要点2：快捷键生成：Ctrl + Alt + T
        try {
    
    
            System.out.println(a/b);
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
        }

        try {
    
    
            new Demo1().divide(1,0);
        } catch (ArithmeticException e) {
    
    
            e.printStackTrace();
        }

    }
    //要点3：
    public void divide(int a,int b)throws ArithmeticException{
    
    
        if (b == 0){
    
    
            throw new ArithmeticException();//主动地抛出异常，一般在方法中使用
        }
    }
}

5.自定义异常

6.总结

思维导图制作的知识框架（Java SE总结）暂时未完成，后续添加上。