• 面向对象


    1.类:模板,⽤来定义⼀类对象的⽅法和属性,⽐如⼈、学⽣、猫,万物都是有模板,都是可 以定义为类。 (类名⾸字⺟⼤写)

    class Student{
    }
    class Person{
    }
    class Cat{
    }

    对象:类的实例化,⽐如 学⽣这个类实例化,就是 XX同学

    Student student = new Student();
    Cat cat1 = new Cat();
    new Persion();

    方法:⽅法是语句的集合,在⼀起完成⼀个功能

      ⽅法包含于类或对象中,即普通⽅法或者类⽅法

    修饰符 返回值类型 ⽅法名(参数类型 参数名){
     ...
     ⽅法体
     ...
     return 返回值;
    }

    继承:⼦类继承⽗类的特征和⾏为,使得⼦类对象具有⽗类的⽅法和属性

      ⽗类也叫基类,具有公共的⽅法和属性

        动物<-猫

        动物<-狗

    多态

      同⼀个⾏为具有多个不同表现形式的能⼒

      优点:减少耦合、灵活可拓展

      ⼀般是继承类或者重写⽅法实现

    抽象

      关键词abstract声明的类叫作抽象类,abstract声明的⽅法叫抽象⽅法

      ⼀个类⾥包含了⼀个或多个抽象⽅法,类就必须指定成抽象类

      抽象⽅法属于⼀种特殊⽅法,只含有⼀个声明,没有⽅法体

    teacher类

    package day3;
    
    public class Teacher {
    
        private int age;
    
        private String name;
    
        private int sex;
    
        public void tech(){
            System.out.println("教学");
        }
    
        public void sleep(){
            System.out.println("睡觉");
        }
    }

    school类

    package day3;
    
    public class School {
    
        private String name;
    
        private String address;
    
        private int age;
    
        private Teacher [] teachers;
    
        public void addTearcher(){
    
        }
    
        public void setTeachers(Teacher[] teachers){
            this.teachers = teachers;
        }
    
        public Teacher[] getTeachers() {
            return teachers;
        }
    
        public void setName(String name){
            this.name = name;
        }
    
        public String getName(){
            return name;
        }
    
        public void setAge(int age){
            if(age>0){
                this.age = age;
                System.out.println("设置完成");
            }else{
                System.out.println("非法参数");
            }
    
        }
    
        public static void main(String [] args){
            System.out.println("主入口");
            School school = new School();
            school.setAge(1);
            Teacher teacher1 = new Teacher();
            teacher1.tech();
        }
    
    }

    2.构造函数:⼀种特殊的⽅法,创建对象时⽤来初始化对象,每次使⽤new 创建对象的时候,就会使⽤构造函数。与类具有相同的名称,但是没有返回值,Java会⾃动为每个类提供⼀个默认构造函数,如果⾃⼰定义了构造函数,就不再使⽤默认构造函数,如果没有显示的写出默认构造函数, 则会消失。

    注意点:如果构造函数之间互相调⽤,务必写在⽅法第⼀⾏

    构造函数种类

    默认构造函数

    public 类名(){
    }

    ⽆参构造函数

    public 类名(){
    //写⾃定义的语句
    }

    有参构造函数

    public 类名(参数类型1 参数名1,参数类型2 参数名2...){
    //⾃定义⽅法体
    }

    构造函数的修饰符

      public ⽤的最多,⽤来创建对象

      private 私有化构造函数,不给外部创建对象,⽐如⼯具类,或者单例设计模式

      default 默认的话,只能在当前包⾥⾯使⽤new 创建对象,⼏乎不⽤

    user 类

    package day3;
    //一个类里面可以有多个构造函数
    public class User {
    
        private int age;
    
        private String name;
    
    //    构造函数,相当于这个对象初始化
    //    如果构造函数之间互相调用,务必写在方法第一行
        public User(){
            System.out.println("这是默认构造函数");
            this.age = age;
    
        }
    
        public User(String name, int age){
            this.name = name;
            this.age = age;
        }
    
        public void setAge(int age){
            if(age>0){
                this.age = age;
            }else{
                System.out.println("非法参数");
            }
        }
    
        public int getAge(){
            return age;
        }
    
        public String getName(){
            return name;
        }
    
        public void setName(String name){
            this.name = name;
        }
    
        public void sleep(){
            System.out.println("睡觉");
            String name = this.getName();
            System.out.println(name+"在睡觉");
        }
    
        public void sleep(String address){
            System.out.println(address);
            System.out.println("睡觉");
        }
    }

    maintest类

    package day3;
    
    public class MainTest {
        public static void main(String [] args){
    //        test1();
    //        test2();
            test3();
        }
    
        public static void test3(){
            User user = new User();
        }
    
        public static void test2(){
            String name = "一把手";
            int age = 5;
    
            User u = new User(name,age);
            User u2 = new User();
            System.out.println(u.getName());
        }
    
        public static void test1(){
            User user = new User();
            user.setAge(10);
            System.out.println(user.getAge());
            user.setName("大爷灰");
            System.out.println(user.getName());
        }
    }

    3.封装

      封装是把过程和数据包围起来,对数据的访问只能通过已定义的接⼝即⽅法

      在java中通过关键字private,protected和public实现封装。什么是封装?封装把对象的所有组成部分组合在⼀起,封装定义程序如何引⽤对象的数据,封装实际上使⽤⽅法将类的数据隐藏起来,控制⽤户对类的修改和访问数据的程度。 适当的 封装可以让代码更容易理解和维护,也加强了代码的安全性.

      类封装

      ⽅法封装

    overload(重载,过载)

      在⼀个类⾥⾯,⽅法名字相同,⽽参数不同,和返回类型⽆关

    override(重写,覆盖)

      ⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写, 返回值和形参都不能改变

        返回值类型,⽅法名,参数类型以及个数

      ⼦类能够根据需要实现⽗类的⽅法

    3.this关键字

      当⼀个对象创建后,JVM会给这个对象分配⼀个引⽤⾃身的指针,这个指针的名字就是 this

      只能⽤于⾮静态⽅法体内,静态⽅法和代码块不能出现this

      this就是指向当前对象本身

    使⽤场景:

      this(参数类型1 参数名,...) 表示当前类对应的构造函数

      ⽅法形参和对象的属性重名,⽤this来区分

    public void setAge(int age){
     this.age = age;
    }

    4,继承

      ⼦类继承⽗类的特征和⾏为,使得⼦类对象具有⽗类的⽅法和属性

      ⽗类也叫基类,具有公共的⽅法和属性,⽣活中的例⼦

        动物<-猫

        动物<-狗

      java中的继承,减少重复代码

      格式,通过extends关键字

    class ⽗类名称{
    
    }
    class ⼦类名称 extends ⽗类名称{
    
    }

    特点

      ⼦类拥有⽗类的⾮private的属性和⽅法

      ⼦类可以⽤⾃⼰的⽅式实现⽗类的⽅法 override(重写,覆盖)

      实现了代码的复⽤

      重写从⽗类那⾥继承来的⽅法的,当调⽤⽅法时候会优先调⽤⼦类的⽅法(默认就近原则)

    注意:

      不⽀持多继承,⽀持多重继承,多重继承提⾼了耦合性,组合优于继承

      所有的类都是继承于 java.lang.Object

      final关键字

        修饰的类,则这个类不可以被继承

        修饰⽅法,则这个⽅法不允许被覆盖(重写)

    living类

    package day3;
    
    public class Living {
    
        public void run(){
            System.out.println("运动");
        }
    }

    animal类

    package day3;
    
    public class Animal extends Living{
    
        private String name;
    
        private int age;
    
        public String getName(){
            return name;
        }
    
        public void setName(String name){
            this.name = name;
        }
    
        public int getAge(){
            return age;
        }
    
        public void setAge(int age){
            this.age = age;
        }
    
        public void sleep(){
            System.out.println("闭着眼睛睡觉");
        }
    }

    dog类

    package day3;
    
    public class Dog extends Animal{
    
        public void eat(){
            System.out.println("狗吃骨头");
        }
    
        @Override
        public void sleep(){
            System.out.println("狗白天不着眼睛睡觉");
        }
    
        public void test(){
        //调用父类的方法,super表示父对象的引用
        super.sleep();
        //调用当前类的方法,this表示当前对象的引用
        this.sleep();
        }
    }

    EetendsMainTest类

    package day3;
    
    public class EetendsMainTest {
        public static void main(String [] args){
            Dog dog = new Dog();
            dog.setAge(1);
            dog.setName("旺财");
            System.out.println(dog.getAge());
            dog.sleep();
            dog.eat();
            dog.test();
        }
    }

    5.继承

      ⼀个引⽤变量,⽤于引⽤⽗类对象

      ⽗类和⼦类都具有相同的命名⽅法,要调⽤⽗类⽅法时使⽤

      ⽗类和⼦类都具有相同的命名属性,要调⽤⽗类中的属性时使⽤

      super也是⽗类的构造函数,格式 super(参数)

      注意点 调⽤super() 必须是类构造函数中的第⼀条语句,否则编译不通过

    注意

      每个⼦类构造⽅法的第⼀条语句,都是隐含地调⽤super(),如果⽗类没有这种形式的构造函 数,那么在编译的时候就会报错

    public class Father {
     public Father(){
     System.out.println("father ⽆参构造函数");
     }
    }
    public class Children extends Father{
     public Children(){
     //默认存在,写和不写都⾏
     super();
     System.out.println("Child⽆参构造函数");
     }
    }

      this()和super()都指的是对象,均不可以在static环境中使⽤

      包括:static变量,static⽅法,static语句块。

    构造函数 super和this

      this 和super在构造函数中只能有⼀个,且都必须是构造函数当中的第⼀⾏

      当⽗类的构造函数是⽆参构造函数时,在⼦类的构造函数中,不⽤显式super()去调⽤⽗类的 构造函数,

      当⽗类的构造函数是有参构造函数时,如果⼦类的构造函数中不写super()进⾏调⽤⽗类的构造函数,编译器会报错。

    java继承后类的初始化顺序

      问题:静态代码块、⾮静态代码、⽗类/⼦类⽆参构造⽅法、⽗类/⼦类的⼀般⽅法

    father类

    package day3;
    
    public class Father {
    
        static {
            System.out.println("父类静态代码块");
        }
    
        public Father(){
            System.out.println("father 无参构造函数");
        }
    
        public Father(int age){
            System.out.println("father 有参构造函数");
        }
    
        public void sleep(){
            System.out.println("father sleep方法");
        }
    }

    children类

    package day3;
    
    public class Children extends Father{
    
        static {
            System.out.println("Child静态模块");
        }
    
        public Children(){
            System.out.println("Child 无参构造函数");
            super.sleep();
        }
    
        public void sleep(){
            System.out.println("Child sleep方法");
        }
    
    }

    SuperTest类

    package day3;
    
    public class SuperTest {
        public static void main(String [] args){
            new Children().sleep();
        }
    }

    6.抽象

      需求:动物都有年龄和名称,但是吃的不⼀样,⽺吃草,⽼⻁吃⾁,但是都是闭着眼睛睡觉的

           ⻋,都有名称和价格,也有跑的⽅法,但是最⾼速度或者动⼒来源不⼀样

      当⽗类的某些⽅法不确定时,可以⽤abstract关键字来修饰该⽅法,即抽象⽅法,⽤abstract 来修饰该类,即抽象类

      抽象类将事物的共性的东⻄提取出来,由⼦类继承去实现,代码易扩展、易维护

      java中的抽象类和抽象⽅法

    //抽象类
    abstract class 类名{
    }
    //抽象⽅法,不能有⽅法主体
    abstract 返回类型 ⽅法名();

    Vehicle类

    package day4;
    
    public abstract class Vehicle {
    
        public abstract void run();
    
        public void stop(){
            System.out.println("停在路上");
        }
    }

    Bicycle类

    package day4;
    
    public class Bicycle extends Vehicle{
    
        @Override
        public void run() {
            System.out.println("人力驱动");
        }
    }

    Auto类

    package day4;
    
    public class Auto extends Vehicle {
    
        @Override
        public void run() {
            System.out.println("汽油驱动");
        }
    }

    AbstractTest类

    package day4;
    
    public class AbstractTest {
    
        public static void main(String [] args){
            Bicycle bicycle = new Bicycle();
            Auto auto = new Auto();
    
            bicycle.run();
            bicycle.stop();
    
            auto.run();
            auto.stop();
    
    //        不能 new 抽象类
    //        new Vehicle();
        }
    }

    抽象特点:

      抽象类的特点

        抽象类不能被实例化,因为抽象类中⽅法未具体化,这是⼀种不完整的类,所以不能直 接实例化,编译⽆法通过

        抽象类中不⼀定包含抽象⽅法,但是有抽象⽅法的类必定是抽象类

        如果⼀个抽象类中可以没有抽象⽅法,这样做的⽬的是为了此类不能被实例化。

        抽象类的⼦类必须给出抽象类中的抽象⽅法的具体实现,否则⼦类也是抽象类,需要⽤ abstract声明

        抽象类不能使⽤final关键字修饰,因为final修饰的类是⽆法被继承

      抽象⽅法的特点

        抽象类中的抽象⽅法只是声明,不包含⽅法体

        抽象⽅法不能⽤private修饰,因为抽象⽅法必须被⼦类实现(覆写),⽽private权限 对于⼦类来 说是不能访问的

        ⼀个类继承了⼀个抽象类,那么它必须全部覆写抽象类中的抽象⽅法,当然也可以不全 部覆写,如果 不覆写全部抽象⽅法则这个⼦类也必须是抽象类

      构造⽅法,类⽅法(即static 修饰的⽅法)不能声明为抽象⽅法

    7.接口

      是抽象⽅法的集合,接⼝通常以interface来声明,⼀个类通过继承接⼝的⽅式,从⽽来继承 接⼝的抽象⽅法

      语法

    interface 名称 [extends 其他的接⼝名] {
     // 声明变量
     // 抽象⽅法
     int getMoney();
    }

    接⼝的特点

      接⼝的⽅法都是抽象⽅法,默认都是 public abstract,其他修饰符都会报错

      接⼝中可以含有变量,但是接⼝中的变量会被隐式的指定为 **public static final**

      类描述对象的属性和⽅法,⽽接⼝则包含类要实现的⽅法

      接⼝⽆法被实例化,需要被实现才⾏

      ⼀个实现接⼝的类,必须实现接⼝内所描述的所有⽅法,否则就必须声明为抽象类

    接⼝和类的区别

      接⼝没有构造函数

      接⼝⾥可以有静态⽅法和⽅法体

      接⼝中所有的⽅法必须是抽象⽅法(JDK8之后就不是)

      接⼝不是被类继承了,⽽是要被类实现

      接⼝⽀持多继承, 类不⽀持多个类继承

    接⼝的实现implements

      当类实现接⼝的时候,类要实现接⼝中所有的⽅法,不然类必须声明为抽象的类,使⽤ implements关键字实现所有接⼝

    语法

    class 类名 implements 接⼝名称[, 其他接⼝名称, 其他接⼝名称]{
     //要实现的⽅法
    }

    注意

      ⼀个类只能继承⼀个类,但是能实现多个接⼝

      接⼝能继承另⼀个接⼝,接⼝的继承使⽤extends关键字,和类继承⼀样

    JDK8新特性

      interface中可以有static⽅法,但必须有⽅法实现体,该⽅法只属于该接⼝,接⼝名直接调⽤ 该⽅法

      接⼝中新增default关键字修饰的⽅法,default⽅法只能定义在接⼝中,可以在⼦类或⼦接⼝ 中被重写

      default定义的⽅法必须有⽅法体

      ⽗接⼝的default⽅法如果在⼦接⼝或⼦类被重写,那么⼦接⼝实现对象、⼦类对象,调⽤该 ⽅法,以重写为准

      本类、接⼝如果没有重写⽗类(即接⼝)的default⽅法,则在调⽤default⽅法时,使⽤⽗类 定义的default⽅法逻辑

    IPay类

    package day4;
    
    public interface IPay {
    
    //    static 修饰符定义静态方法
        static void staticMethod() {
            System.out.println("接口中的静态方法");
        }
    
    //    default 修饰符定义默认方法,默认方法不是抽象方法,可以重写也可以不重写
        default void defaultMethod() {
            System.out.println("接口中的默认方法");
        }
    }

    Alipay类

    package day4;
    
    public class Alipay implements IPay {
    
        @Override
        public void defaultMethod() {
            System.out.println("重写后的方法");
        }
    }

    interfaceTest类

    package day4;
    
    public class interfaceTest {
    
        public static void main(String [] args){
    
            IPay.staticMethod();
            Alipay alipay = new Alipay();
            alipay.defaultMethod();
        }
    }

    8.面向对象编程之InstanceOf关键词和多态

    InstanceOf 关键词:是Java的⼀个⼆元操作符(运算符),也是Java的保留关键字

    作用:判断⼀个类是否实现了某个接⼝,或者判断⼀个实例对象是否属于⼀个类

    语法

    //如果该object 是该class的⼀个实例,那么返回true。如果该object 不是该class的⼀个实例,或者object是null,则返回false
    
    boolean result = object instanceof class
    
    参数:
      result :boolean类型。
      object :必选项。任意对象表达式。
      class:必选项。任意已定义的对象类。

    对象类型强制转换前的判断

    Person p1 = new Student();
    //判断对象p是否为Student类的实例
    if(1p instanceof Student)
    {
     //向下转型
     Student s = (Student)p1;
    }

    ⽅法重写和重载

    ⽅法重写 overriede:⼦类对⽗类的允许访问的⽅法的实现过程进⾏重新编写,

    注意点

      返回值和形参都不能改变

      ⽗类的成员⽅法只能被它的⼦类重写

      final 和 static的⽅法不能被重写

      构造⽅法不能被重写

      访问权限不能⽐⽗类中被重写的⽅法的访问权限更低

    ⽅法重载 overload

      ⼀个类⾥⾯,⽅法名字相同但参数不同,返回类型可以相同也可以不同

      ⽐如构造函数重载

    注意核⼼区分

    override是在不同类之间的⾏为,overload是在同⼀个类中的⾏为

    总结:Java多态

      同⼀个⾏为具有多个不同表现形式或形态的能⼒

    常⻅的⽅式:继承⽅法重写、同类⽅法重载、抽象⽅法、接⼝

    10.写个计算器,能完成加减乘除运算

      定义接⼝做参数

      加减乘除定义4个类

      定义⼀个静态⼯具类,把下⾯的接⼝作为其中⼀个形参对象,传递具体的运算符类完成计算

    ICompute类

    package day4;
    
    //计算机接口
    public interface ICompute {
        /**
         * 通过传递两个参数,完成传递
         * @param num1
         * @param num2
         * @return
         */
        int computer(int num1, int num2);
    }

    AddOper类

    package day4;
    
    public class AddOper implements ICompute {
        @Override
        public int computer(int num1, int num2) {
            return num1 + num2;
        }
    }

    SubOper类

    package day4;
    
    public class SubOper implements ICompute {
    
        @Override
        public int computer(int num1, int num2) {
            return num1 - num2;
        }
    }

    MulOper类

    package day4;
    
    public class MulOper implements ICompute {
    
        @Override
        public int computer(int num1, int num2) {
            return num1*num2;
        }
    }

    DeviceOper类

    package day4;
    
    public class DeviceOper implements ICompute {
    
        @Override
        public int computer(int num1, int num2) {
            try {
                return num1/num2;
            }catch (Exception e){
                e.printStackTrace();
            }
            return -1;
        }
    }

    UseComputer类

    package day4;
    
    public class UseComputer {
    
        public static void computer(ICompute compute, int num1, int num2){
            int result = compute.computer(num1, num2);
            System.out.println(result);
        }
        public static void main(String [] args){
            UseComputer.computer(new AddOper(),25,5);
            UseComputer.computer(new SubOper(),25,5);
            UseComputer.computer(new MulOper(),25,5);
            UseComputer.computer(new DeviceOper(),25,0);
        }
    
    }
    dayehui
  • 相关阅读:
    MySQL 可重复读,差点就让我背上了一个 P0 事故
    Thread.sleep(0) 有什么用
    你不会还在用这8个错误的SQL写法吧?
    Spring事务失效的 8 大原因
    我说 SELECT COUNT(*) 会造成全表扫描,面试官让我回去等通知
    这么写参数校验(Validator)就不会被劝退了
    HyperLedger Fabric 1.4 基础环境搭建(7)
    HyperLedger Fabric 1.4 简介(6.1)
    HyperLedger Fabric 1.4 关键技术(6.4)
    HyperLedger Fabric 1.4 交易流程(6.3)
  • 原文地址:https://www.cnblogs.com/zrh-960906/p/14125660.html
Copyright © 2020-2023  润新知