狂神说-java面向对象

• 本质：以类的方式组织代码，以对象的组织（封装）数据
• 三大特性：
  • 封装
  • 继承
  • 多态
• 方法的调用
  • 静态方法：可以直接通过类名调用
  • 非静态方法：需要先实例化这个类 new

		//对象类型 对象名 = 对象值;
        Student student = new Student();
        
        student.say();

• 静态方法区：static声明的方法是和类一起加载的，所以所有方法都可以调用它

封装

• 属性私有，get / set

package com.oop.demo03;

public class Student {

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

    public int getAge() {
        return age;
    }

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

    //提供一些可以操作这个属性的方法！
    //提供一些public的get、set方法
    public void setName(String name) {
        this.name = name;
    }

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

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

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }
}

package com.oop;


import com.oop.demo03.Student;

/*
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());
    }
}

继承

• extends 拓展
• 子类和父类直接，有 “子类 is a 父类” 的关系
• Java中类只有单继承，没有多继承！（一个儿子只有一个爸爸，但一个爸爸可以有多个儿子）

super

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

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

重写

重写：需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表列表必须相同
3.修饰符：范围可以扩大： public > Protected > Default > private
4.抛出的异常：范围，可以被缩小，但不能扩大： ClassNotFoundException --> Exception（大）

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

为什么需要重写：
1.父类的功能，子类不一定需要，或者不一定满足子类的需求
Alt + Insert：override

多态

• 动态编译：类型：可扩展性

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.run();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        //s2.eat();
        ((Student) s2).eat();   //强制类型转换


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

不能被重写的方法，自然没有多态
    1.static 方法，属于类，它不属于实例
    2.final 常量
    3.private方法
 */

instance of

System.out.println(X instanceof Y); //能不能编译通过，就看二者是否有父子关系

• 类型转换

public static void main(String[] args) {

        //类型之间的转化： 父    子
        
        //高     低
        Person obj = new Student();

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

        ((Student) obj).go();   //等价于下面两行
//        Student student = (Student) obj;
//        student.go();

    }

    /*
    信息量大的转信息量小的会 信息丢失，信息量小的转信息量大的会 信息缺失
    1.父类引用指向子类的对象
    2.把子类转换为父类，向上转型
    3.把父类转换为子类，向下转型：强制转换
    4.方便方法的调用，减少重复的代码。简洁
     */

抽象类

• abstract修饰符可以用来修饰方法也可以用来修饰类，分别对应抽象方法和抽象类
• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类
• 不能用new关键字创建 抽象类 的对象，抽象类是用来给子类继承的
• 抽象方法只有方法的声明，没有方法的实现，在子类中完成具体的实现
• 子类继承抽象类，则必须实现抽象类没有实现的方法，否则该子类也要声明为抽象类

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

    //约束~子类中实现~
    //abstract，抽象方法，只有方法名字，没有方法的实现!
    public abstract void doSomething();

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

}

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

    }
}

接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范
• 声明类的关键字是 class，声明接口的关键字是 interface

package com.oop.demo06;

//抽象类的思维
//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 com.oop.demo06;

public interface TimeService {
    void timer();
}

package com.oop.demo06;

public class UserServiceimpl implements UserService, TimeService {
    @Override
    public void timer() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}
/*
作用：
    1.约束
    2.定义一些方法，让不同的人实现
    3.方法：public abstract
    4.常量：public static final
    5.接口不能被实例化，接口中没有构造方法
    6.implements可以实现多个接口（实现“多继承”）
    7.接口中的方法必须都被重写
 */

内部类

• 内部类就是在一个类的内部再定义一个类，比如AA类中定义一个B类，那么B类相对于A类就称为内部类，而A类相对于B类就是外部类了
• 1.成员内部类
• 2.静态内部类
• 3.局部内部类
• 4.匿名内部类

package com.oop.demo07;

public class Outer {

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

    public class Inner{ //若用static的话则不可以输出
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
    
    //局部内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }

}

//一个java类中可以有多个class类，但只能有一个public class类
class A{
    public static void main(String[] args) {

    }
}

public class Test {
    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();
}