Java基础语法（五）-CFANZ编程社区

Java基础语法（五）

面向对象定义

什么是面向对象：
在这里插入图片描述
面向对象的本质：

方法的定义和调用

在这里插入图片描述

类与对象的创建

在这里插入图片描述
示例代码：

package com.gavin.oop;

public class Student {

    //属性值
    String name;
    int age;

    //方法
    public void study() {
        System.out.println(this.name + "在学习");
    }
}

package com.gavin.oop;

public class Application {

    public static void main(String[] args) {

        //实例化学生类
        Student xiaoming = new Student();
        Student xiaohong = new Student();

        //给实例化出来的xiaoming对象赋值
        xiaoming.name = "张三";
        xiaoming.age = 23;
        System.out.println(xiaoming.name);
        System.out.println(xiaoming.age);

        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
    }
}

执行结果：
在这里插入图片描述
面向对象的本质：

构造器详解

在这里插入图片描述
示例代码：

package com.gavin.oop;

public class Person {

    String name;

    int age;

    //无参构造器
    //创建对象使用new关键字，本质是调用构造器
    //构造器用来初始化值
    public Person() {
    }

    //有参构造器
    //一旦定义了有参构造器，无参构造器也要定义
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

package com.gavin.oop;

public class Application2 {

    public static void main(String[] args) {
        //使用有参构造器给Person对象中的属性赋值
        Person person = new Person("张三", 23);
        System.out.println(person.name);
        System.out.println(person.age);
    }
}

执行结果：
在这里插入图片描述

创建对象内存分析

在这里插入图片描述

封装详解

在这里插入图片描述
示例代码：

package com.gavin.oop;

public class Person2 {

    //属性值用private修饰，表示私有
    private String name;

    private int age;

    //set方法用来设置属性的值
    public void setName(String name) {
        this.name = name;
    }

    //get方法用来获取属性的值
    public String getName() {
        return name;
    }

    //set方法中可以自己定义，用来校验传入的值是否合法
  public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.age = 3;   //不合法
        } else {
            this.age = age; //合法
        }
    }

    public int getAge() {
        return age;
    }
}

package com.gavin.oop;

public class Application3 {

    public static void main(String[] args) {
        Person2 person2 = new Person2();
        person2.setName("张三");
        //传入不合法的值
        person2.setAge(123);
        System.out.println(person2.getName());
        System.out.println(person2.getAge());
    }
}

执行结果：
在这里插入图片描述
封装的作用：

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

继承

在这里插入图片描述
示例代码：
先定义一个Person类，有money属性，有say()方法

package com.gavin.oop.Demo05;

public class Person {

    private int money;

    public int getMoney() {
        return money;
    }

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

    public void say() {
        System.out.println("人类会说话");
    }
}

再定义一个Student类，使用extends关键字继承Person类

package com.gavin.oop.Demo05;

public class Student extends Person{

    public static void main(String[] args) {
        Student student = new Student();
        student.setMoney(100000000);
        System.out.println("money=" + student.getMoney());
        student.say();
    }
}

执行结果：
在这里插入图片描述
Student类继承了Perosn类后，就拥有了Person类中的money属性和say方法，这就是继承的含义。Java中的继承为单继承，也就是说Student类继承了Person类后，就不能再继承其它的类了，而Person类还可以被其它的类继承。这就相当于现实生活中，一个儿子只有一个爹，而一个爹可以有多个儿子的道理一样。

super详解

super关键字用在Java的继承中，子类可以用super来调用类中的属性和方法
示例代码：
先定义一个Person类，有name属性，并赋值为张三，还有一个print方法

package com.gavin.oop.Demo05;

public class Person {

    protected String name = "张三";

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

再定义一个Student类，也有name属性和print方法，给name属性赋值为李四

package com.gavin.oop.Demo05;

public class Student extends Person{

    private String name = "李四";

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

    public void test(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
        System.out.println("调用方法");
        this.print();
        super.print();
    }
}

测试类中调用方法，并传入name参数的值为王五

package com.gavin.oop.Demo05;

public class Application {

    public static void main(String[] args) {
        Student student = new Student();
        student.test("王五");
    }
}

执行结果：
在这里插入图片描述
可以看出使用子类中使用super关键字，可以调用父类中属性和方法
使用super关键字的注意点：

方法重写

子类继承父类后，可以对父类中的方法进行重写，以便满足自己的需求
示例代码：
先创建一个B类对象，里面有一个test()方法

package com.gavin.oop.Demo05;

public class B {

    public void test() {
        System.out.println("B==>test()");
    }
}

再创建一个A类对象用来继承B类，然后重写B类中的test()方法

package com.gavin.oop.Demo05;

public class A extends B{

    @Override
    public void test() {
        System.out.println("A==>test()");
    }
}

测试类代码：

package com.gavin.oop.Demo05;

public class Application {

    public static void main(String[] args) {
        A a = new A();
        a.test();
        //父类引用指向子类对象
        B b = new A();
        b.test();
    }
}

执行结果：
在这里插入图片描述
可以看出B类和A的test()方法执行的结果都是一样的，原因就是A类重写了B类中的test()方法，使得B类中的test()方法和子类中test()方法一样

什么是多态

在这里插入图片描述
示例代码：
先创建一个Person对象，里面有一个run()方法

package com.gavin.oop.Demo06;

public class Person {

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

再创建一个Student对象继承Person类，然后重写run()方法，再添加一个eat方法

package com.gavin.oop.Demo06;

public class Student extends Person{

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

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

测试类代码：

package com.gavin.oop.Demo06;

public class Application {

    public static void main(String[] args) {
        /**
         * 一个对象的实际类型是确定的，可以指向的引用类型就不确定了，父类的引用指向子类对象
         */
        //Student 能调用的方法都是自己或者继承父类的
        Student student = new Student();
        //Person 夫类型 可以指向子类，但是不能调用子类中的方法
        Person person = new Student();

        student.run();
        person.run();

        //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大
        student.eat();
        //person.eat(); 父类中不能调用子类中的方法

    }
}

执行结果：
在这里插入图片描述
多态注意事项：

instanceof关键字

instanceof关键字主要用来判断两个对象或者值，是否为同一类型，同一类型返回true，表示可以强制转换，不是同一类型就返回false，不能强行转换。
在这里插入图片描述
示例代码：

package com.gavin.oop.Demo06;

public class Person {

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

package com.gavin.oop.Demo06;

public class Student extends Person{

}

package com.gavin.oop.Demo06;

public class Teacher extends Person{
}

package com.gavin.oop.Demo06;

public class Application {

    public static void main(String[] args) {
        /**
         * Object -> Person -> Student
         * Object -> Person -> Teacher
         * Object -> String
         */
        Object object = new Student();
        System.out.println(object instanceof Student);  //true
        System.out.println(object instanceof Person);   //true
        System.out.println(object instanceof Object);   //true
        System.out.println(object instanceof Teacher);  //true
        System.out.println(object instanceof String);   //true
        System.out.println("===========================");
        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 Teacher);  //false
        //System.out.println(person instanceof String);     编译就报错，无法通过编译
    }
}

可以看出，有父子继承关系的返回true，表示可以进行强制转换。

static关键字详解

static关键字可以用来修改变量，常量以及类中的方法，使用static修饰后不用创建对象，直接用对象名.来调用变量，常量和方法。
示例代码：

package com.gavin.oop.Demo07;

public class Student {

    //静态变量
    private static int age;

    //非静态变量
    private double score;

    public static void main(String[] args) {
        Student student = new Student();
        //使用static可以直接使用类名调用
        System.out.println(Student.age);
        System.out.println(student.age);
        System.out.println(student.score);
    }
}

执行结果：
在这里插入图片描述
匿名代码块，静态代码块，构造方法的执行顺序
示例代码：

package com.gavin.oop.Demo07;

public class Person {

    {
        System.out.println("匿名代码块");
    }

    static {
        System.out.println("静态代码块");
    }

    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("============");
        Person person2 = new Person();
    }
}

执行结果：
在这里插入图片描述
可以看出静态代码块最先执行，接着是匿名代码块，最后是构造方法，而且静态代码块只随着类加载执行一次。

静态导入包示例代码：

package com.gavin.oop.Demo07;

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

public class Test {

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

执行结果：
在这里插入图片描述
静态导入包以后，使用方法时直接写方法名就可以调用。

抽象类

在这里插入图片描述
示例代码：

package com.gavin.oop.Demo08;

//用abstract修饰，表示抽象类
public abstract class Action {

    //用abstract修饰，表示抽象方法
    public abstract void doSoming();

    //抽象类中也可以写蒲绒的方法
    public void say() {
        System.out.println("说话");
    }
}

package com.gavin.oop.Demo08;

public class A extends Action{
    
    //继承了抽象类要重写中没有实现的方法
    @Override
    public void doSoming() {
        System.out.println("工作ing");
    }
}

package com.gavin.oop.Demo08;

public class Application {

    public static void main(String[] args) {
        //new Action() 抽象类不能被实例化
        //继承了抽象类的子类，才可以实例化
        A a = new A();
        a.doSoming();
    }
}

执行结果：
在这里插入图片描述
抽象类的注意点：

接口的定义和实现

在这里插入图片描述
示例代码：

package com.gavin.oop.Demo09;

//interface 定义接口的关键字，接口都需要实现类实现
public interface UserService {

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

package com.gavin.oop.Demo09;

public interface TimeService {

    void timer();
}

package com.gavin.oop.Demo09;

//类使用implements关键字实现接口
//实现了接口的类，就要重写接口中的方法
//可以利用接口实现多继承
public class UserUserviceImpl implements UserService, TimeService{
    @Override
    public void timer() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void query(String name) {

    }
}

接口的作用：
在这里插入图片描述

内部类

在这里插入图片描述
成员内部类示例代码：

package com.gavin.oop.Demo10;

public class Outer {

    private int age = 10;
    public void out() {
        System.out.println("这是外部类的方法");
    }

    class Inner{
        public void in() {
            System.out.println("这是内部类的方法");
        }
        //获取外部类的私有属性
        public void getAge() {
            System.out.println(age);
        }
    }
}

package com.gavin.oop.Demo10;

public class Application {

    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过外部类实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getAge();
    }
}

执行结果：
在这里插入图片描述
以上就是成员内部类的具体用法，其它的内部类可以自己试着写一下。