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

面向对象的本质

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

三大特性

封装、继承和多态

类和对象的关系

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