当前位置: 萬仟网 > IT编程>软件设计>面向对象 > 面向对象三大特性介绍

面向对象三大特性介绍

2020年08月01日  | 萬仟网IT编程  | 我要评论
面向对象概念什么是面向对象:三大特性:封装、继承、多态。方法的调用在同一个类中:对于静态方法,其他的静态或非静态方法都可以直接调用它。而对于非静态方法,其他的非静态方法是可以直接调用它的。但是其他静态方法只有通过对象才能调用它。在不同类中:静态方法/非静态方法调用静态方法 类名.方法名 调用即可静态方法/非静态方法调用非静态方法 实例化这个类 即new一个实例化对象 eg:一个类只能有一个public class类,而class可以有多个。值传递和引用传递pac

什么是面向对象:

在这里插入图片描述
三大特性:封装、继承、多态。

方法的调用

在同一个类中:

对于静态方法,其他的静态或非静态方法都可以直接调用它。

而对于非静态方法,其他的非静态方法是可以直接调用它的。但是其他静态方法只有通过对象才能调用它。

在不同类中:

静态方法/非静态方法调用静态方法 类名.方法名 调用即可

静态方法/非静态方法调用非静态方法 实例化这个类 即new一个实例化对象 eg:
在这里插入图片描述
一个类只能有一个public class类,而class可以有多个。

值传递和引用传递

package com.atxins.idea.oop; //值传递 public class Demo02 { public static void main(String[] args) { int a= 1; System.out.println(a); //1 change(a); System.out.println(a); //1 } public static void change(int a){ a=10; } } 
package com.atxins.idea.oop; //引用传递:对象,本质还是值传递 public class Demo03 { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name); //null change(person); System.out.println(person.name); //wangfei } public static void change(Person person){ //person是一个对象:指向的---->Person person = new Person();这是一个具体的人,可以改变属性! person.name="wangfei"; } } //定义一个Person类,有一个属性:name class Person{ String name; //null } 

构造器详解

在这里插入图片描述
注意:一个类即使什么都不写,它也会存在一个方法。

Demo示例:

构造器的作用是:1,2。

定义了有参构造之后,如果想使用无参构造,显示的定义一个无参构造。
在这里插入图片描述

创建对象的内存分析

对象是通过引用来操作的:栈—>堆
在这里插入图片描述

封装

记住这句话就够了:属性私有,get/set(有时会做一些安全性验证)

封装的意义:

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

继承

在这里插入图片描述

super详解

super();注意点

  1. 默认调用父类的无参构造。
  2. 如果要显示调用父类的构造器,必须要在子类构造器的的第一行。
  3. super必须只能出现在子类的方法或构造方法中!
  4. super和this不能同时调用构造方法。

Vs this:

代表的对象不同:

this:本身调用者这个对象

super:代表父类对象的应用

前提:

this:没有继承也可以使用。

super:只能在继承条件下使用。

构造:

this();本类的构造;

super();父类的构造!

四种修饰符的具体区别

1、public:同一类下都可以直接进行调用
2、private:作用于当前类。
3、protected:作用于同一包下的子孙类。

4、default:作用同一包下的。

public>protected<default<private

即:类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开(public),对于不是同一个包中的其他类相当于私有(private)。

Java中,外部类的修饰符只能是public或默认,类的成员(包括内部类)的修饰符可以是以上四种。

方法的重写

方法重载和方法重写的区别

区别点 重载 重写(覆写)
英文 overloading overriding
定义 方法名称相同,参数的类型或个数不同,与返回类型无关;对权限没有要求 方法名称,参数类型,返回值类型全部相同(即子类的方法和父类必须一致;方法体不同。)
范围 发生在一个类中 发生在继承类中

重写注意点:

  1. 修饰符:范围可以扩大但不能缩小
  2. 抛出的异常:范围,可以被缩小,但不能扩大。
  3. 为什么需要重写:父类的功能,子类不一定需要,或者不一定满足!
  4. 重写都是方法的重写,和属性无关。
  5. 重写只和非静态方法有关。

代码示例:

package com.atxins.idea.ChongXie; // 父类 public class B { public void test(){ System.out.println("B=>text"); } } 
package com.atxins.idea.ChongXie; //子类 public class A extends B{ //Override 重写 @Override public void test() { System.out.println("A=>text"); } } 
package com.atxins.idea.ChongXie; public class Test { //非静态:重写 public static void main(String[] args) { A a = new A(); a.test(); //父类的引用指向了子类 B b = new A();//子类重写了父类的方法 b.test(); } } 

结果:
在这里插入图片描述

多态

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

多态注意事项:

  1. 多态是方法的多态,属性没有多态。

  2. 一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多。
    在这里插入图片描述

  3. 父类和子类,有联系。 类型转化异常 ClassCastException!

  4. 存在条件:有继承关系、子类重写父类的方法、父类引用指向子类对象。 Father f1 = new son();

    有些方法不能被重写

    • static 方法,属于类,它不属于示例。
    • final 常亮
    • private 方法。

示例Demo:
在这里插入图片描述

instanceof和类型转换

instanceof (类型转换)引用类型,可以判断两个类之间是否存在父子关系,有父子关系,true。否则,false。

类型转换:

  • 父类引用指向子类对象
  • 把子类转换为父类,向上转型;
  • 把父类转换子类,向下转型;强制转换,可能丢失自己的本来的一些方法。
  • 方便方法的调用,减少重复的代码,简洁。
    静态代码块只执行一次。

抽象类

package com.atxins.idea.Demo01; //abstract抽象类 public abstract class Action { //约束~有人帮我们实现 //abstact,抽象方法,只有方法名,没有方法的实现。 public abstract void doSomething(); //1.不能new这个抽象类,只能靠子类去实现它;约束! //2.抽象类中可以写普通的方法~ //3.抽象方法必须在抽象类中 //抽象的抽象:约束 } 
package com.atxins.idea.Demo01; //抽象类的所有方法,继承了它的子类,都必须要实现它的方法~ 除非子类也是抽象类 public class A extends Action { @Override public void doSomething() { } } 

思考:抽象类中含有构造器吗?

抽象类可以有构造方法,只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。

如果你不能对抽象类实例化那么构造函数的作用是什么?好吧,他可以用来初始化抽象类内部声明的通用变量,并被各种实现使用。

接口

在这里插入图片描述

package com.atxins.idea.demo02; 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); } 

作用:

  1. 约束
  2. 定义一些方法,让不同的人实现
  3. 默认的方法:public abstract
  4. 默认的常量:public static final
  5. 接口不能被实例化,接口没有构造方法。
  6. implements可以实现多个接口
  7. 必需要重写接口中的方法

N中内部类

成员内部类:
在这里插入图片描述

静态内部类:
在这里插入图片描述

局部内部类:

package com.atxins.idea.demo03; public class Outer { //局部内部类(方法里) public void method(){ class Inner{ public void in(){ System.out.println("good"); } } } } 

匿名内部类:

package com.atxins.idea; public class Test { public static void main(String[] args) { //没有名字初始化类(即匿名内部类),不用将实例保存到变量中。 new Apple().eat(); //new 用来实现接口中方法 new UserService(){ @Override public void hello() { } }; } } class Apple{ public void eat(){ System.out.println("1"); } } interface UserService{ void hello(); } 

Error和Exception

异常的简单分类:

  1. 检查型异常 :通常是用户错误或问题引起的

  2. 运行时异常:运行时异常可以在编译时被忽略

  3. 错误ERROR:错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。例如,当栈溢出时,一个错误就发生了,它们在编译也检查不到的。

异常结构体系

java把异常当做对象来处理,并定义一个基类java.lang.Throwable作为所有异常的超类。
在这里插入图片描述

捕获和抛出异常

try-catch:

package com.atxins.idea.exception; //手动添加 public class Test { public static void main(String[] args) { int a=0; int b=0; //假设要捕获多个异常:从小到大! try { //try监控区域 System.out.println(a/b); new Test().a(); }catch (ArithmeticException r){ //catch(想要捕获的异常类型!最高Throwable)捕获异常 System.out.println("程序出现异常,变量b不能为0"); }catch (Exception e) { System.out.println("Exception"); }catch (Throwable t) { System.out.println("Throwable"); } finally { //处理善后工作 System.out.println("finally"); } //finally  可以不要finally,但一些IO、资源,关闭需在finally里进行 } public void a(){ b(); } public void b(){ a(); } } 
package com.atxins.idea.exception; //自动添加 public class Test02 { public static void main(String[] args) { int a=0; int b=0; //Ctrl+Alt+t  选中要包裹的代码,快捷键自动生成 try { System.out.println(a/b); } catch (Exception e) { e.printStackTrace(); //打印错误的栈信息 } finally { } } } 

throw、throws:

package com.atxins.idea.exception; public class Test03 { public static void main(String[] args) { try { new Test03().test(1,0); } catch (ArithmeticException e) { e.printStackTrace(); } } //假设这方法中,处理不了这个异常。可从方法上抛出异常-->throws,不在打印异常信息 public void test(int a,int b)throws ArithmeticException{ if(b==0){ //throw throws throw new ArithmeticException();//主动抛出异常,一般在方法中使用 } } } 

常见的一些异常:

算术异常类:ArithmeticExecption
空指针异常类:NullPointerException
类型强制转换异常:ClassCastException
数组负下标异常:NegativeArrayException
数组下标越界异常:ArrayIndexOutOfBoundsException
违背安全原则异常:SecturityException
文件已结束异常:EOFException
文件未找到异常:FileNotFoundException
字符串转换为数字异常:NumberFormatException
操作数据库异常:SQLException
输入输出异常:IOException
方法未找到异常:NoSuchMethodException

自定义异常

demo示例:

package com.atxins.idea.demo04; //自定义的异常类 public class MyException extends Exception{ //传递数字>10; private int detail; public MyException(int a) { this.detail=a; } //toString:异常的打印信息 @Override public String toString() { return "MyException{"+detail+"}"; } } 
package com.atxins.idea.demo04; //测试类 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); //调用test方法,因为抛出了异常,所以要捕获它/或者继续抛出. } catch (MyException e) { System.out.println("MyException=>"+e); //处理异常,增加一些处理异常的代码块 //输出自己定义的消息e(不要简单的调用printStackTrace去打印输出) } } } 

try-catch和throw、throws的区别和联系

区别一:throw 是语句抛出一个异常;throws 是方法抛出一个异常;
throw语法:throw <异常对象>
在方法声明中,添加throws子句表示该方法将抛出异常。如果一个方法会有异常,但你并不想处理这个异常,就在方法名后面用throws,这样这个异常就会抛出,谁调用了这个方法谁就要处理这个异常,或者继续抛出.
throws语法:[<修饰符>]<返回值类型><方法名>([<参数列表>])[throws<异常类>]
其中:异常类可以声明多个,用逗号分割。
区别二:throw要么和try-catch-finally语句配套使用,要么与throws配套使用。但throws可以单独使用,然后再由处理异常的方法捕获。

联系一:try … catch 就是用catch 捕获 try 中的异常,并处理;catch是捕获异常。也就是说某一个操作有可能会抛出什么异常。throw 就是不处理异常,直接抛出异常

调用一个会throws exception的方法(在方法定义的时候可以用throws实现)时,需要把这个方法放在try里,然后用catch破获这个exception,做相应的处理。

throw new exception()是抛出一个exception,由别的method来破获它。

也就是说try…catch是为破获别人的exception用的,而throw是自己抛出exception让别人去破获的。

实际应用中的一些总结:
在这里插入图片描述

使用try-catch捕获处理异常后,程序就不会停止了。try和catch只能获取程序运行时引发的异常,而throw语句可以引发明确的异常,程序到了throw语句这后就立即停止,不会执行后面的程序。

/***
 * http://www.flvcd.com/
 *  .--,       .--,
 * ( (  \.---./  ) )
 *  '.__/o   o\__.'
 *     {=  ^  =}
 *      >  -  <
 *     /       \
 *    //       \\
 *   //|   .   |\\
 *   "'\       /'"_.-~^`'-.
 *      \  _  /--'         `
 *    ___)( )(___
 *   (((__) (__)))    高山仰止,景行行止.虽不能至,心向往之。
 */ 

本文地址:https://blog.csdn.net/Achard_Wang/article/details/108241804

如您对本文有疑问或者有任何想说的,请点击进行留言回复,万千网友为您解惑!

相关文章:

验证码:
Copyright © 2017-2020  萬仟网 保留所有权利. 粤ICP备17035492号-1