面向对象的相关知识及实例

面向对象的本质

以类的方式组织代码，以对象的组织（封装）数据。

三大特性

封装、继承和多态

类和对象的关系

1. 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。

2. 对象是抽象概念的具体实例

   Application

   package com.oop.demo02;
   
   public class Application {
       public static void main(String[] args) {
   
           //类，抽象的，实例化
           //类实例化后悔返回一个自己的对象
           //student对象就是一个student类的具体实例
           Student xiaoming = new Student();
           Student xh = new Student();
   
           xiaoming.name = "小明";
           xiaoming.age = 3;
   
           System.out.println(xiaoming.name);
           System.out.println(xiaoming.age);
           xiaoming.study();
   
           xh.name = "小红";
           xh.age = 4;
   
           System.out.println(xh.name);
           System.out.println(xh.age);
           xh.study();
   
       }
   }
   

   Student

   package com.oop.demo02;
   //学生类
   public class Student {
       //属性 ： 字段
       String name;
       int age;
   
       public void study(){
           System.out.println(this.name + "在学习");
       }
   }
   

构造器

Person

package com.oop.demo002;

//java ---> class
public class Person {
    //一个类即使什么都不写，他也会存在一个方法
    //显示的定义构造器

    String name;

    //实例化初始值
    //1、使用new关键字 本质是在调用构造器
    //2、用来初始化值
    public Person() {
        this.name = "夜月";
    }

    //有参构造
    public Person(String name) {
        this.name = name;
    }

    //alt + insert
}
/*
构造器：
1、和类名相同
2、没有返回值
作用：
1、new 本质在调用构造方法
2、初始化对象的值
注意点：
1、定义有参构造之后，如果想使用无参构造，先得定义一个无参构造

Alt + Insert

this.*
 */

Application

package com.oop.demo002;

public class Application {
    public static void main(String[] args) {
        //new 实例化一个对象
        Person person = new Person();

        System.out.println(person.name);

        Person yeyue = new Person("深夜");

        System.out.println(yeyue.name);

    }
}

对象的创建

Application

package com.oop.demo03;

public class Application {
    public static void main(String[] args) {
        Pet dog = new Pet();
        dog.name = "小白";
        dog.age = 3;
        dog.shout();

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


/*
1、类是一个模板 抽象，对象是一个具体实例
2、方法： 定义、调用
3、对象的引用：
   引用类型：基本类型（8）外，对象是通过引用俩操作的 ：栈--->堆
4、属性：字段Field 成员变量
            默认初始化：
            数字： 0 0.0
            char ： u000
            bloolean: false
            引用： null
5、对象的创建和使用
    -必须使用new 关键字创造对象，构造器 Person haha = new Person（）
    -对象的属性 haha.name
    -对象的方法 haha.sleep()
6、类
    静态的属性 属性
    动态的行为 方法

    封装 继承 多态
 */

Pet

package com.oop.demo03;

public class Pet {
    public String name;
    public int age;

    //无参构造

    public void shout() {
        System.out.println("叫了一声");
    }
}

封装

1. 高内聚，低耦合（高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合就是仅暴露少量的方法给外部使用）
2. 属性私有，get/set

封装的好处

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

Application

package com.oop.demo04;

/*
1、提高程序的安全性，保护数据
2、隐藏代码的实现细节
3、统一接口
4、系统可维护增加
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("夜月");

        //方法名，参数列表
        System.out.println(s1.getName());

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

        s1.setAge(-1);
        System.out.println(s1.getAge());

        s1.setAge(86);
        System.out.println(s1.getAge());
    }

}

Student

package com.oop.demo04;

public class Student {

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

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

    public String getName() {
        return this.name;
    }

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

    //Alt + Insert


    public int getId() {
        return id;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.age = 3;
        } else {
            this.age = age;
        }

    }
}

继承

1. 本质对某一批类的抽象，从而实现对现实世界的建模。
2. extends的意思是“扩展”，子类是父类的扩展
3. Java中类只有单继承，没有多继承
4. 继承是类和类之间的一种关系，还有依赖、组合、聚合等
5. 继承关系的两个类：子类（派生类）、父类（基类）。子类继承父类，使用关键字extends来表示
6. 子类和父类之间，从意义上来讲应该有“is a ”的关系

super注意点

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

super vs this

1. 代表对象不同

   ​ this：本身调用者这个对象

   ​ super：代表父类对象的应用

2. 前提

   ​ this：没有继承也可以使用

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

3. 构造方法

   ​ this():本类的构造

   ​ super():父类的构造

Application

package com.oop.demo05;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();

        System.out.println("==================================================");

        student.say();
        System.out.println(student.mony);

        student.test("深夜暗月");
        System.out.println("==================================================");
        student.test1();
    }

}

Person

package com.oop.demo05;

//在Java中，所有的类，都默认直接或者间接的继承object
//person 人 ：  父类
public class Person {

    public Person() {
        System.out.println("Person无参构造执行了");
    }

    //public
    //protected
    //default
    //private
    //私有的东西无法被继承
    protected String name = "yeyue";

    public int mony = 10_0000_0000;

    private int savemony = 10_0000_0000;

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

    public int getSavemony() {
        return savemony;
    }

    public void setSavemony(int savemony) {
        this.savemony = savemony;
    }

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

Student

package com.oop.demo05;
//学生 is 人；源生类，子类
public class Student extends Person{
//Ctrl + H


    public Student() {
        //隐藏代码：调用父类的无参构造
        super();//调用父类的构造器，必须在子类的构造器的第一行
        System.out.println("Student无参构造执行了");
    }

    private String name = "shenye";

    public void test(String name){
        System.out.println(name);//深夜暗月
        System.out.println(this.name);//shenye
        System.out.println(super.name);//yeyue
    }

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

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

方法的重写

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

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符，范围可以扩大不能缩小 public>Protected>Default>private
4. 抛出的异常：范围，可以缩小，但不能扩大 ClassNotFoudException–>Exception(大)

重写，子类的方法和父类必须一致，方法体不同！

Application

package com.oop.demo06;

public class Application {

    //静态的方法和非静态的方法区别很大
            //静态方法：//方法的调用只和左边，定义的数据类型有关

    //非静态重写
    public static void main(String[] args) {

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

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

    }
}

Person

package com.oop.demo06;

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

}

Student

package com.oop.demo06;

public class Student extends Person {

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

多态

1. 同一方法可以根据发送对象的不同而采用多种不同的行为方式
2. 一个对象的实际类型是确定的，但是可以指向对象的引用类型有很多
3. 多态是方法的多态，属性没有多态性

注意事项

1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常！ ClassCastException！
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ father f1 = new Son();

Application

package com.oop.demo006;

public class Application {
    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(); //子类重写了父类的方法，执行子类的方法
        s1.eat();
        //s2.eat
        
    }
}

Person

package com.oop.demo006;

public class Person {

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

Student

package com.oop.demo006;

public class Student extends Person {
    @Override
    public void run() {
        System.out.println("Son");
    }

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

instanceof和类型转换（Application和Application1最好有一个）

Application1

package com.oop.demo07;

public class Application1 {

    public static void main(String[] args) {

        //Object > String
        //Object >Person > Teacher
        //Object > Person > Stuent
        Object object = new Student();

        // System.out.println(x instanceof y);

        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);//false
        System.out.println(object instanceof String);//false

        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);

        System.out.println("==============================================");

        Student student = new Student();

        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);
        //System.out.println(student instanceof String);
    }
}

Application

package com.oop.demo07;

public class Application {

    public static void main(String[] args) {
        //类型之间的转化： 父 子

        //子类转换为父类，可能丢失自己的本来的一些方法

        //高
        Person obj = new Student();

        //student将这个对象转化为Student类型，就可以使用Student类型的方法

        Student student = (Student) obj;
        student.go();
        ((Student)obj).go();

    }
}

/*
1. 父类调用指向子类的对象
2. 把子类转换成父类，向上转型
3. 把父类转换成子类，强制转换
4. 方便方法的调用，减少重复的代码！简洁
 */

Person

package com.oop.demo07;

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

}

Student

package com.oop.demo07;

public class Student extends Person {
    public void go(){
        System.out.println("go");
    }

}

Teacher

package com.oop.demo07;

public class Teacher extends Person {
}

static关键字

Person

package com.oop.demo08;

public class Person {

    //2. 赋初值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }

    //1.只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }

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

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

    }

}

Student

package com.oop.demo08;

public class Student {
    private static int age; //静态变量
    private double score;   //非静态变量

    public void run(){
        go();
    }

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

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        //System.out.println(Student.score);
        System.out.println(s1.age);
        System.out.println(s1.age);

        go();
    }
}

Test

package com.oop.demo08;

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);
    }
}

抽象类

Action

package com.oop.demo09;

//abstract 抽象类：类 extends：单继承~  （接口可以多继承）
public abstract class Action {

    //约束~有人帮我们实现~
    //abstract ,抽象方法，只有方法名字，没有方法实现
    public abstract  void doSomething();
}


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

抽象的抽象：约束~
 */

A

package com.oop.demo09;

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法 除非他也是抽象类
public class A  extends Action{
    @Override
    public void doSomething() {

    }
}

接口

1. 只有规范！自己无法写方法~专业的约束

2. 定义了一组的规则，大家一起遵守！接口的本质就是契约

3. public abstract //接口中的所有定义其实都是抽象的
   

4. public static final //常量
   

5. 接口不能被实例化~，接口中没有构造方法

6. implements可以实现多个接口

7. 实现了接口的类就必须要重写接口中的方法

UserServiceImpl

package com.oop.demo10;

//抽象类 ： extends
//类 可以实现接口
//实现了接口的类，就需要重写接口中的方法~

//多继承~利用接口实现多继承
public class UserServiceImpl 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() {

    }
}

UserService

package com.oop.demo10;


//抽象的四位~ Java
//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);


}

TimerService

package com.oop.demo10;

public interface TimeService {
    void timer();
}

内部类

实例1：

Application

package com.oop.demo11;

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

    }
}

Outer

package com.oop.demo11;

public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获取外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }

}
//一个java类中可以有多个class类，但是只能有一个public class

实例2：

Test

package com.oop.demo12;

import com.oop.demo10.UserService;

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

        UserServiceP userServiceP = new UserServiceP() {
            @Override
            public void hello() {

            }
        };
    }
}

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

interface UserServiceP{
    void hello();
}

Outer

package com.oop.demo12;

public class Outer {
    //局部内部类
    public  void method(){

        class Iner{
            public void in(){

            }
        }

    }

}
//一个java类中可以有多个class类，但是只能有一个public class