面向对象基础

面向对象

本质:以类的方式组织代码,以对象的组织(封装)数据

三大特性

1. 封装
2. 继承
3. 多态

构造器

package oop.demo01;

public class Preson {

    //一个类即使什么都不写,也会存在一个方法
    String name;

    //1.使用new关键字,本质是在调用构造器
    //2.用来初始化值
    public Preson(){

    }

    //有参构造:一旦定义了有参构造,无参就必须显示定义
    public Preson(String name){
        this.name=name;
    }
    /*
    构造器:
       1.和类名相同
       2.没有返回值
    作用:
     */
}

封装

package oop.demo04;

/**
 * 1.封装的意义
 * 2.提高程序的安全性,保护数据
 * 3.统一接口
 * 4.系统的可维护增加了
 */
public class Student {

    //属性私有

    /**
     * 名字
     */
    private String name;
    /**
     * 学号
     */
    private int id;

    /**
     * 性别
     */
    private char sex;

    //提供一些可以操作这个属性的方法
    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }
}

重写

package oop.demo05;

//重写都是方法的重写,和属性无关
public class A extends B{

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

    /*
       重写:需要有继承关系,子类重写父类的方法
       1.方法名必须相同
       2.参数列表必须相同
       3.修饰符 : 范围可以扩大但不能被缩小
       4.抛出的异常 : 范围,可以被缩小,但不能扩大

       子类的方法名要跟父类一样,但方法体不同
     */

}

继承

package oop.demo05;


/**
 * 继承
 * 1.子类继承了父类,就会拥有父类的全部方法
 * 2.private 修饰的方法、属性无法被继承
 * 3.java中只有单继承、没有多继承
 */
public class Teacher extends Person{
    private String name="tk";

    public void test(String name){
        System.out.println(super.name);
        System.out.println(this.name);
    }
    /*
        supper:
       1.supper调用父类的构造方法,必须在构造方法的第一个
       2.supper必须只能出现在子类的方法或者构造方法中
       3.supper和this 不能同时调用构造方法
     */

    /*
     VS   this:
       1.代表的对象不同:
            this: 本身调用者这个对象
            supper: 代表父类对象的应用
         前提:
            this :没有继承也可以使用
            supper :只能在继承条件下才可以使用

         构造方法
            this() ；本类的构造
            supper() : 父类的构造
     */


}

多态

package oop.demo06;


/**
 * 多态的注意事项
 * 1.多态是方法的多态,属性没有多态
 * 2.父类和子类,有联系  类型转换异常! ClassCastException
 * 3.存在条件  :继承关系,方法需要重写 ,父类引用指向子类对象!!
 *
 *
 *  1.static 方法属于类,它不属于实例,无法被重写
 *  2.final
 *  3.private
 */
public class Studernt extends Person{

    //instanceof  (类型转换)引用类型
}

代码块

package 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 person1 =new Person();
    }
}

package oop.demo07;

//static
public class Student {


    private static int age;  //静态的变量
    private double score;  //非静态的变量


    public static void go() {

    }

    public static void main(String[] args) {
        go();

    }
}

抽象类

package oop.demo08;


//抽象类的所有方法,继承了他的子类,就必须重写他的方法
public class A extends Action{
    @Override
    public void doSomething() {
        System.out.println("");
    }

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

    //抽象类存在的意义?
            /*
            1.提高开发效率,你品
             */

}

package oop.demo08;


//abstract 抽象类  extends : 单继承
public abstract class Action {

    //抽象方法,只有方法名字,没有方法的实现
    public abstract void doSomething();
}

接口

package oop.demo09;


// 实现了接口的类,就必须重写接口中的方法
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
        System.out.println("add success");
    }

    @Override
    public void delete(String name) {
        System.out.println("delete success");
    }

    @Override
    public void time() {

    }
}

package oop.demo09;


// interface
public interface UserService {

    //默认常量
    int AGE=99;

    //接口中的所有定义其实都是抽象的  public abstract
    void add(String name);

    void delete(String name);

    /*
    作用
        1.约束
        2.定义了一些方法,让不同的人实现
        3.public abstract
        4.public static final
        5.接口不能被实例话 ,接口中没有构造方法
        6.可以实现多个接口
        7.必须重写接口中的方法

     */
}

内部类

package oop.demo10;

public class Outer {
    private int id=10;

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

//    class Inner {
//        public void in() {
//            System.out.println("这是个内部类的方法");
//        }
//
//        //可以获得外部类的私有属性
//        public void getId(){
//            System.out.println(id);
//        }
//    }

    /**
     * 静态内部类
     *
     */
//    public static class Inner{
//
//    }

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

        }
    }

    /**
     * 匿名内部类
     *
     */
}

package oop.demo10;

public class TestApp {

    public static void main(String[] args) {

        Outer outer = new Outer();
//        Outer.Inner inner = outer.new Inner();
//        inner.in();
//        inner.getId();


        /**
         * 匿名内部类
         *
         */
        UserService userService = new UserService() {
            @Override
            public void hello() {
                System.out.println("hello");
            }
        };
    }

    interface UserService {
        void hello();
    }
}