zoukankan      html  css  js  c++  java
  • 面对对象

    面向对象

    面向对象的本质就是:以类的方式组织代码,以 对象的方式封装数据

    new关键字

    • 使用new关键字创建的时候,除了分配内存空间之外,还会给创建好的对象进行默认初始化以及调用构造方法

    构造方法

    创建对象的时候自动调用(无参构造),主要作用是为了初始化

    • 必须和类的名字相同
    • 必须没有返回值,不能写void

    构造方法的重载

    • 构造方法重载成有参构造之后,如果还需要使用无参构造,必须重新建里无参构造
    在IDEA中使用快捷键alt+insert可以快速添加重载构造方法以及get,set方法
    

    静态方法和非静态方法

    • 静态方法:用static修饰,可以直接类名.方法进行调用,从属于类,和类一起加载。
    • 非静态方法:没有用static进行修饰,调用时必须创建对象,从属于对象,和对象一起加载。
    • 静态方法在访问本类的成员时只允许方法问静态成员(静态方法和静态成员变量),不能访问对非静态成员变量和非静态成员方法。而非静态方法可以访问本类的静态成员。主要原因是因为,静态方法是和类一起加载的,非静态方法是和对象一起加载的,对象就是类的实例化,因此在没有实例化之前是无法调用非静态成员的,所以静态方法无法调用非静态成员,同时非静态方法又称为实例方法。

    封装

    • 高内聚,低耦合——程序设计需要追求高内聚,低耦合。高内聚就是类的内部数据操作细节自己完成,不允许外部干涉。低耦合仅暴露少量的方法给外部使用。

    • 封装:应禁止直接访问一个对象中数据的实际表现,而应通过操作接口来访问,这成为信息隐藏。

    • 属性私有,get/set方法

    封装的作用

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

    继承

    • Java中只有单继承是没有多继承的
    • 继承是类和类之间的一种关系。除了继承之外,类和类之间的关系还有依赖、组合、聚合等。
    • 继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends表示
    • 子类和父类的关系,Student继承自Person,Student是Person的子类
    • final修饰的类无法继承
    public class Person{
    }
    //Student继承父类Person
    public class Student extends Person{
    }
    
    • 子类会拥有父类的方法和属性,但是不会继承私有方法和属性
    • 在Java中所有的类都直接或者间接继承Object

    父类和子类的构造方法以及super详解

    //调用父类的构造方法必须卸载子类的构造方法的第一行
    public class Person{
    	public Person() {
            System.out.println("Person");
        }
    }
    //Student继承父类Person
    public class Student extends Person{
        public Student(){
            //这里隐藏了super(),会调用父类的无参构造
            //super();
            System.out.println("Student");
            //不能在这里调用父类构造方法super()
    	}
    }
    
    //若父类只有有参构造,那么子类就无法使用父类无参构造,必须在子类的无参构造中写出父类有参构造
    public class Person{
        //这里写了有参构造,无参构造就没了,需要重新写无参构造
    	public Person(String name) {
            System.out.println("Person");
        }
    }
    //Student继承父类Person
    public class Student extends Person{
        //这里会报错,因为父类是有参构造,子类是无参构造,必须要写出父类的有参构造
        public Student(){
            //这里隐藏了super(),会调用父类的无参构造
            //super();
            super("name");
            System.out.println("Student");
            //不能在这里调用父类构造方法super()
    	}
    }
    

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

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

    • this:本身调用者这个对象。super:代表父类对象的引用
    • this:没有继承也可以使用。super:只能在继承条件才可以使用
    • this();本类的构造。super();父类的构造

    方法的重写

    方法重写和重载完全不同,重载是同类中,方法名相同,参数类型不同,而重写是子类重写父类方法,方法名相同,参数类型相同,修饰符范围可以扩大但是不能缩小,抛出的异常范围可以缩小但是不能扩大。

    //静态成员可以被继承,但是不会被重写,如果子类有同名的静态成员,那么父类的静态成员会被隐藏
    public class A {
        static String str = "A静态成员";
        String str1 = "A非静态成员";
    
        static public void staticPrint() {
            System.out.println("A静态方法");
        }
        public void print() {
            System.out.println("A非静态方法");
        }
    }
    public class B extends A{
        static String str = "B静态成员";
        String str1 = "B非静态成员";
    
        static public void staticPrint() {
            System.out.println("B静态方法");
        }
        public void print() {
            System.out.println("B非静态方法");
        }
    }
    public class C extends A{
    }
    
    //主函数
    public static void main(String[] args) {
        C c = new C();
        System.out.println(c.str);
        System.out.println(c.str1);
        c.staticPrint();
        c.print();
    	//A静态成员
    	//A非静态成员
    	//A静态方法
    	//A非静态方法
    
        A b = new B();
        System.out.println(b.str);
        System.out.println(b.str1);
        b.staticPrint();
        b.print();
        //B静态成员
    	//B非静态成员
    	//B静态方法
    	//B非静态方法
    
    }
    

    为什么需要重写

    • 父类的功能,子类不一定需要或者不一定满足!

    多态

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

    多态存在的条件

    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象
    • 多态是方法的多态,属性没有多态
    //People类
    public class People {
        public void eat() {
            System.out.println("吃饭");
        }
    }
    //学生类
    public class Student extends People{
        @Override
        public void eat() {
            System.out.println("吃水煮肉片");
        }
    
        public void study() {
            System.out.println("学习");
        }
    }
    //测试
    public class Demo05 {
        public static void main(String[] args) {
            People p = new Student();
            p.eat();//输出水煮肉片
            ((Student) p).study();//要调用study()方法需要转换p的类型
    
        }
    }
    
    

    instanceof关键字

    用来判断对象和类之间的继承关系

    //Person->Student
    //Person->Teacher
    Object object = new Student();
    System.out.println(object instanceof Student);//true
    System.out.println(object instanceof People );//true
    System.out.println(object instanceof Object);//true
    System.out.println(object instanceof Teacher);//false
    System.out.println(object instanceof String);//false
    People people = new Student();
    System.out.println(people instanceof Student);//true
    System.out.println(people instanceof People );//true
    System.out.println(people instanceof Object);//true
    System.out.println(people instanceof Teacher);//false
    //System.out.println(people instanceof String);//编译报错,因为People和String都是继承Student的
    

    子类和父类的转换

    • 父类引用指向子类的对象
    • 把子类转换为父类,向上转型
    • 把父类转换成子类,向下转型,强制转换
    • 方便方法的调用,减少重复的代码!
    //子类转换成父类,可能会丢失自己本来的一些方法
    //父 					子
    Person student = new Student();
    //强制转化,将父类转成子类
    Student s = (Student) student;
    

    抽象类

    • abstract修饰的类称为抽象类
    • abstract修饰的方法称为抽象方法
    • 子类继承抽象类,必须重写抽象类中的所有抽象方法
    • 不能new这个抽象类,只能靠子类去实现它。但是抽象类有构造器,只是不能直接创建抽象类的实例对象。在继承抽象类的子类中通过super()可以调用抽象类中的构造方法
    • 抽象类中可以写普通方法
    • 抽象方法必须在抽象类中
    • 抽象类存在的意义:更利于代码的维护和重用

    接口(真的很关键)

    • 普通类:只有具体实现
    • 抽象类:具体实现和规范(抽象方法)都有!
    • 接口:只有规范!自己无法写方法专业的约束约束和实现分离,面向接口编程
    • 接口中的所有定义方法都是抽象的public abstract,所有的变量都定义成常量public static final
    • 接口可以用implements继承多个接口

    内部类

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

    • 成员内部类
    public class Outer {
        private int id = 10;
        public void out() {
            System.out.println("这是外部类方法");
        }
        //成员内部类用static修饰之后无法调用外部类的非静态成员
        class Inner{
            public void in(){
                System.out.println("这是内部类方法");
            }
            public void getID(){
                System.out.println(id);
            }
        }
    }
    
    public class Demo10 {
        public static void main(String[] args) {
    
            Outer outer = new Outer();
            //通过外部类来实例化内部类~
            Outer.Inner inner = outer.new Inner();
            inner.getID();
        }
    }
    

    一个Java文件中可以有多个class类,但是只能有一个public类

    • 局部内部类
    public class LocalInnerClass {
        public static void main(String[] args) {
    
            //定义局部内部类
            class InnerBase{
                int a;
            }
            class  InnerSub extends InnerBase {
                int b;
            }
    
            InnerSub is = new InnerSub();
            is.a = 1;
            is.b = 2;
            System.out.println("a = "+ is.a + " b = "+ is.b);
        }
    }
    
    • 匿名内部类
    public class Demo10 {
        public static void main(String[] args) {
    
            //匿名对象
            new Apple().eat();
            //匿名内部类
            //一般格式, new 类名/抽象类/接口(){};
            new UserService(){
    			//重写接口中的方法
            }
        }
    }
    
    class Apple{
        public void eat(){
            System.out.println("1");
        }
    }
    

    异常

    • 异常处理五个关键词try,catch,finally,throw,throws
    public class Demo01 {
        public static void main(String[] args) {
            int a = 1;
            int b = 0;
    
            //多个catch捕获异常必须要从小到大
            try {
                System.out.println(a/b);
            }catch(ArithmeticException e) {//想要捕获的异常类型,最高级别异常类型Throwable
                System.out.println("被除数不能为0");
                e.printStackTrace();//打印当前异常错误信息
            }finally{
                System.out.println("finally");//无论是否捕获到异常都会运行
                //finally可以不需要
            }
        }
    }
    
    • 抛出异常
    //方法体内抛出异常throw
    public class Demo02 {
        public static void main(String[] args) {
            int a = 1;
            int b = 0;
    
            try {
                if (b == 0) {
                    throw new ArithmeticException();//主动抛出异常
                }
                System.out.println(a/b);
            }finally{
                System.out.println("finally");
            }
        }
    }
    
    //方法抛出异常
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
    
        try {
            new Demo02().test(1,0);
        }catch(ArithmeticException e) {
            System.out.println("被除数不能为0");
        }finally{
            System.out.println("finally");
        }
    }
    public void test(int a, int b) throws ArithmeticException{
        System.out.println(a/b);
    }
    

    自定义异常

    public class MyException extends Exception{
    
        //传递数字>10
        private int detail;
    
        public MyException(int a) {
            this.detail = a;
        }
        //toString:异常的打印信息
    
        @Override
        public String toString() {
            return "MyException{" +
                    "detail=" + detail +
                    '}';
        }
    }
    
    public class Test {
        //可能会存在异常的方法
    
        static void test(int a) throws MyException{
            System.out.println("传递的参数为"+a);
            if(a>10) {
                throw new MyException(a);
            }
            System.out.println("OK");
        }
    
        public static void main(String[] args) {
            try {
                test(11);
            } catch (MyException e) {
                System.out.println("MyException=>"+e);
            }
        }
    }
    

    实际应用中的经验总结

    • 在多重catch后面,可以加一个catch(Exception)来处理可能会被遗漏的异常
    • 对于不确定的代码,也可以假设try-catch,处理潜在的异常
    • 尽量去处理异常,切记简单地调用printStackTrace()打印输出
    • 尽量添加finally语句块去释放占用资源
  • 相关阅读:
    SCI写作经典替换词,瞬间高大上!(转)
    最佳化常用测试函数 Optimization Test functions
    算法复杂度速查表
    VS 代码行统计
    CPLEX IDE 菜单栏语言设置( 中文 英文 韩文 等多国语言 设置)
    如何从PDF文件中提取矢量图
    Matlab无法打开M文件的错误( Undefined function or method 'uiopen' for input arguments of type 'char)
    visual studio 资源视图 空白 解决方案
    MFC DialogBar 按钮灰色不响应
    嗨翻C语言笔记(二)
  • 原文地址:https://www.cnblogs.com/jiangblog/p/12867363.html
Copyright © 2011-2022 走看看