【狂神说Java】面向对象编程OOP

面向对象的本质：以类的方式组织代码，以对象的组织封装数据。

三大特性：封装，继承，多态

回顾方法的定义

---

package oop;

import java.io.IOError;
import java.io.IOException;

//Demo01类
public class Demo01 {
    //main方法
    public static void main(String[] args) {

    }
    /*
    修饰符  返回值类型  方法名(...){
        //方法体
        return 返回值;
    }
     */
    //return 结束方法，返回一个结果
    public String sayhello(){
        return "helloworld";
    }
    public void hello() {
        return;
    }
    public int max(int a,int b){
        return a>b?a:b;//三元运算符
    }
    //break：跳出switch，结束循环
    //数组下标越界：Arrayindexoutofbounds异常
    //异常抛出：后面讲解,IO流读文件会抛出异常
    public void readfile(String file)throws IOException{

    }
}

回顾方法的调用

---

    //遵循一个原则：被static修饰的内容会跟随类的加载而加载，
    //所以静态化的内容可以不用实例化就直接调用，同时两个静态方法之间也可以互相调用
    //有static的方法属于静态的，没有static的方法属于实例的（类似于变量），
    //同时加载的可以相互调用或者先加载的可以调用后加载的，但是后加载的不可以调用先加载的
    public static void a(){
        b();//静态的不能调用非静态的
    }
    //类实例化之后才存在
    public void b(){
        a();//非静态的可以调用静态的
    }

public class Demo03 {
    public static void main(String[] args) {
        int add=new Demo03().add(1,2);
        System.out.println(add);
    }
    public int add(int a,int b){
        return a+b;
    }
}

public class Demo04 {
    //值传递
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);//1
        Demo04.change(a);
        System.out.println(a);//1
    }
    public static void change(int a){
        a=10;
    }
}
//对于基本数据类型来说，给形参传递的是实参值的副本，
// 而对于引用数据类型来说，传递的则是地址的副本。
// 但由于地址的副本和原来的相似，
// 因此传递过去后的形参也指向同一个内存空间中。

public class Demo05 {
    //引用传递
    //值传递，只是把值传过去了，在函数里修改变量的值，原变量的值不变，引用传递是把地址传过去了，修改变量的值，原变量的值也会变
    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);//null
        Demo05.change(person);
        System.out.println(person.name);//孙孙
    }
    public static void change(Person person){
        person.name="孙孙";
    }
}
//定义了一个person类，有一个属性：name
class Person{
    String name;
}

类和对象的关系

---

对象是抽象概念的具体实例。

使用new关键字创建对象。

构造器详解

---

类中的构造器也称构造方法，是在进行创建对象时必须要调用的，有以下两个特点：1.必须和类名相同；2.必须没有返回类型，也不能写void。

package oop.demo02;

public class Person {

    //一个类即使什么都不写，也会存在一个方法

    //显示的定义构造器
    String name;
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    //2.用来初始化值
    public Person(){

    }

    //有参构造:一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name1){
        this.name=name1;
    }
    //快捷键：alt+insert


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

        //new实例化一个对象
        Person person = new Person("孙孙孙");
        System.out.println(person.name);

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

创建对象内存分析

---

封装

---

该露的露，该藏的藏；高内聚，低耦合；属性私有，get/set。

即类的内部数据操作细节自己完成，不允许外部干涉，且仅暴露少量的方法给外部使用。

public class Studentt {
    //属性私有
    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;
    }
    
    //快捷键：鼠标右键generate
    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

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

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

    public static void main(String[] args) {
        Studentt s1 = new Studentt();
        s1.setName("孙孙");
        System.out.println(s1.getName());

        s1.setAge(70);
        System.out.println(s1.getAge());
    }
*/

继承

---

继承的本质是对某一批类的抽象，extends是扩展，子类是父类的扩展。

继承是类和类之间的一种关系，继承关系的两个类，一个为子类，一个为父类，子类继承父类，使用关键字extends表示。

在Java中类只有单继承，没有多继承。即一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子。

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

public class Personn {
    private int money=10000000;
    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}
/*
//学生 is 人
//子类继承了父类，就会拥有父类全部的方法
public class Studentdemo extends Personn{

}
*/
/*
//老师 is 人
public class Teacher extends Personn{

}
*/
/*
public class Application {
    public static void main(String[] args) {
        Studentdemo student = new Studentdemo();
        student.say();
        student.setMoney(1000000);
        System.out.println(student.getMoney());
    }
}
*/

super

---

注意点：

1.super是调用父类的构造方法，必须在构造方法的第一个，默认隐藏

2.super必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法

super vs this：

代表对象不同：

this：本身调用者对象

super：代表父类对象的引用

前提：

this：没有继承也可以使用

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

构造方法：

this（）：默认调用本类

super（）：调用了父类

package oop.demo02;
//人：父类
//在java中，所有的类，都默认直接或间接继承object
public class Personn {

    //无参构造器
    public Personn() {
        System.out.println("person无参执行了");
    }
    protected String name="孙孙";
    //私有的无法被继承
    
    public void print(){
        System.out.println("Person");
    }
}

package oop.demo02;
//学生 is 人，派生类，子类
//子类继承了父类，就会拥有父类全部的方法
public class Studentdemo extends Personn{
    //ctrl+H

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

    private String name="哈哈";
    
    public void print() {
        System.out.println("Student");
    }
    
    public void test1(){
        print();//Student
        this.print();//Student
        super.print();//person
    }
    
    public void test(String name){
        System.out.println(name);//伊伊
        System.out.println(this.name);//哈哈
        System.out.println(super.name);//孙孙
    }
}

package oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Studentdemo student = new Studentdemo();//此时结果为：person无参执行了 student无参执行了
       // student.test("伊伊");

       // student.test1();
    }
}

方法重写

---

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

1.方法名必须相同；

2.参数列表必须相同；

3.修饰符：范围可以扩大，不能缩小。public>protectes>default>private

4.抛出的异常：范围可以被缩小，但不能扩大；ClassNotFoundException->Exception(大) 不行

子类的方法和父类必须一致，但方法体不同。

为什么需要重写：

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

2.快捷键：鼠标右键Generate ->override

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

package oop.demo02;

public class A extends B{
/*
    public void test(){
        System.out.println("A=>test()");
    }
 */
    //快捷键
    @Override//重写
    public void test() {
        System.out.println("A=>test()");
    }
}

package oop.demo02;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //静态方法和非静态方法区别很大
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//A=>test()

        //父类的引用指向了子类
        B b=new A();//非静态：子类重写了父类的方法
        b.test();//B=>test(),非静态时结果为A=>test()
    }
}

多态

---

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

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

注意事项：

1.多态是方法的，属性没有多态；

2.父类和子类，有联系，类型转换异常，ClassCasstException；

3.存在条件：有继承关系，方法需要重写，父类引用指向子类对象；

有些方法不能被重写：

1.static方法，属于类

2.final 常量；

3.private方法

//父类
public class C {
    public void run(){
        System.out.println("run");
    }
}

//子类
public class D extends C{

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

//一个项目应该只存在一个main方法
public class Application {

    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        D d = new D();
        //可以指向的引用类型就不确定了，父类的引用指向子类
        C d1 = new D();
        Object d2 = new D();

        //对象能执行哪些方法主要看对象左边的类型，和右边无关
        //D子类能调用的方法都是自己的或者是继承父类的
        d1.run();//run//son,子类重写了父类的方法，执行子类的方法
        d.run();//son
        //C父类可以指向子类，但不能调用子类独有的方法
        d.eat();
        ((D)d1).eat();//强制转换，高转低
        //d1.eat();错误，因为父类没有eat方法
    }
}

instanceof

---

    public static void main(String[] args) {

        //instanceof作用是看左边和右边是否有父子关系

        //Object>String
        //Object>Person>Teacher
        //Object>Person>Student
        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);//false
        System.out.println(object 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 Teacher);//false
        //System.out.println(person instanceof String);//false,编译报错

        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);//false,报错
        //System.out.println(student instanceof String);//false，报错
    }

强制转换

---

//Person类里有go方法
//高转低
Person obj=new Student();
((Student)obj).go();

//低转高，子类转父类，可能会丢失自己本来的一些方法
Student student=new Student();
Person person=student;
person.go();//报错

static关键字

---

//public final class Teacher  被final修饰的类，不能被继承，断子绝孙
public class Teacher{
    private static int age;//静态的变量,多线程用到
    private double score;//非静态的变量

    public void run(){
        go();//非静态方法可以调用静态方法里的东西
    }
    public static void go(){

    }

    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        System.out.println(Teacher.age);
        //静态变量对于类而言只有一个，可以被类中的实例去共享
        System.out.println(teacher.age);
        System.out.println(teacher.score);
        
        //静态方法可以调用静态方法的，但不能调用非静态方法的
        go();
        //run();报错

    }

    {
        //匿名代码块，在构造器之前，和对象同时产生，用来赋初始值
        System.out.println("匿名代码块");//第二个
    }
    static {
        //静态代码块，类一加载就执行，只执行一次
        System.out.println("静态代码块");//第一个被输出，只执行一次
    }

    public Teacher() {
        System.out.println("构造器");//第三个
    }

}

抽象类

---

1.不能new抽象类，只能靠子类去实现它，是一个约束；

2.抽象类里可以写普通方法；

3.抽象方法必须在抽象类中；

4.抽象类存在构造器，new子类会自动执行父类构造。

//abstract 抽象类
//java类是单继承的，但是接口可以实现多继承
public abstract class Action {
    //只有方法名字，没有方法实现
    public abstract void run();

}

//继承了抽象类的子类，必须要实现抽象类(父类)中的抽象方法。（自己的梦想实现不了，交给儿子)，除非子类也是抽象类
public class B extends Action{
    @Override
    public void run() {

    }
}

接口

---

只有规范（抽象方法），自己无法写方法。约束和实现分离。接口的本质是契约，就像法律一样，制定好后大家都遵守。声明接口的关键字是interface。

作用：

1.约束；

2.定义方法，让不同的人实现；

3.方法都是public abstract；

4.常量都是public static final；

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

6.implements可以实现多个接口；

7.必须要重写接口中的方法；

 public interface UserService {
    //接口中的所有定义都是抽象的，接口都需要有实现类
    //直接写返回值类型 方法名 参数
    //下面定义了四个方法
    void add(String name);
    void delete(String name);
    void change(String name);
    void select(String name);
}
//另一个接口
public interface TimeService {
    void timer();
}

//接口的实现类一般以Impl结尾，使用implements关键词
//alt+enter快捷键，如果要实现接口里的所有定义，必须要重写所有方法
//多继承：利用接口实现
public class UserServiceImpl implements UserService,TimeService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void change(String name) {

    }

    @Override
    public void select(String name) {

    }

    @Override
    public void timer() {

    }
}

内部类

---

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

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
        //局部内部类
        class Inner2{

        }
    }
    //内部类
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void gerID(){
            System.out.println(id);
        }
    }
}
//一个Java类中可以有多个class类，但只能有一个public class
class A{
    //可以写测试类，因为可以写main方法
    public static void main(String[] args) {

    }
}

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();//这是内部类的方法
        inner.gerID();//10，//获得外部类的私有属性
    }
}