首页 / JAVA / Java面向对象进阶
Java面向对象进阶
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java面向对象进阶,小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含9957字,纯文字阅读大概需要15分钟。
内容图文
面向对象进阶
1类的继承
概念
-
类的继承是指在一个现有类的基础上去构建一个新的类,构建出来的新类被当作子类,现有的类被称作父类
-
使用extends关键字来声明一个类继承另一个类
-
一个类只能继承自一个父类,多个类可以继承父类,父类可以继承自其他父类,父类和子类是相对概念
-
调用子类构造器时会先调用父类的构造器
public class Person { protected String name="person's name"; public Person() { System.out.println("Person无参构造执行了"); } public void print() { System.out.println("person"); } }
public class Student extends Person{ private String name="student's name"; public Student(){ //隐藏代码 调用父类构造器 System.out.println("Student无参构造执行了"); } }
public class Demo { public static void main(String[] args) { Student s1=new Student(); s1.test(); } }
重写父类方法
- 在继承关系中,子类会自动继承父类中定义的方法,但有时在子类中需要对继承的方法进行一些修改,即对父类方法的重写
- 在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值的类型
public class Person {
protected String name="person's name";
public Person()
{
System.out.println("Person无参构造执行了");
}
public void print()
{
System.out.println("person");
}
}
public class Student extends Person{
private String name="student's name";
public Student(){
//隐藏代码 调用父类构造器
System.out.println("Student无参构造执行了");
}
//重写了父类方法
public void print()
{
System.out.println("student");
}
}
public class Demo {
public static void main(String[] args)
{
Student s1=new Student();
//print被重写了,所以此时调用的是子类的print(),会输出student
s1.print();
}
}
super关键字
-
当子类重写父类的方法后,子类对象将无法访问父类被重写的方法
-
super关键字可以用于访问父类的成员
public class Person { protected String name="person's name"; public Person() { System.out.println("Person无参构造执行了"); } public void print() { System.out.println("person"); } }
public class Student extends Person{ private String name="student's name"; public Student(){ //隐藏代码 调用父类构造器 System.out.println("Student无参构造执行了"); } public void print() { System.out.println("student"); } public void test1(){ print();//student this.print();//调用子类的构造方法,此时会输出student super.print();//调用父类的构造方法,此时会输出person } public void test() { System.out.println(this.name); System.out.println(super.name); } }
public class Demo {
public static void main(String[] args)
{
Student s1=new Student();
s1.test();
}
}
2final关键字
- final修饰的类不能被继承
- final修饰的方法不能被子类重写
- final修饰的变量(成员变量和局部变量)是常量,只能被赋值一次
3抽象类和接口
抽象类的特点
1.不能new这个类,只能靠子类去实现它
2.抽象类可以写普通的方法
3.抽象方法必须在抽象类中
- 代码
//abstract 抽象类的关键字
public abstract class Action {
//约束,等待子类实现
//abstract抽象方法,只有方法的名字,没有方法的实现
public abstract void doSomething();
}
//继承自抽象类的方法,必须实现父类(抽象类)的所有方法,除非该类也是抽象类
public class A extends Action {
@Override
public void doSomething() {
}
}
接口
-
接口与其他类的区别
- 普通类:只有具体实现
- 抽象类:具体实现和规范(抽象方法)都有
- 接口:只有规范,自己无法写方法,定义的是一种规则
-
interface
//interface 定义的关键字,接口都需要有实现类
public interface UserService {
//接口里定义的属性都是常量
int AGE=99;
//接口中的所有定义其实都是抽象的public abstract
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
//类 可以实现接口 implements一个接口
//实现了接口中的类,必须要重写接口中的方法
public class UserServiceImp1 implements UserService {
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
}
- 接口的作用
- 实现约束(常量都是 public static final 方法都是 public abstract,实现接口必须重写接口中的方法)
- 定义一些方法,让不同的人实现
- 接口可以实现多继承(接口不能被实例化,没有构造方法)
4多态
类型转化
-
在同一个方法中,由于参数类型不同而导致执行效果各异的现象就是多态
-
为了实现多态,允许使用一个父类类型的变量来引用一个子类类型的对象,根据被引用子类对象特征的不同,得到不同的运行结果。
-
将子类对象当作父类对象时不需要任何显示声明,但是此时不能通过父类对象来调用子类的方法
-
将父类对象变成子类对象要向下转型,要显示声明
public class Demo { static public void main(String[] args) { //高 低 Person person=new Student(); //子类转化为父类可能会丢失方法,此时obj不再能用StudentEat() //Student将这个对象转化为Student类型,我们就可以使用Student类型的方法了 ((Student)person).StudentEat(); //低 高 //Student student=new Person();这样转直接报错 Person person1=new Person(); //此时把person1转化为student,并赋值给student Student student=(Student)person1; } }
public class Person { public void run() { System.out.println("run"); } public void PersonSay() { System.out.println("say"); } }
public class Teacher2 extends Person{
void print()
{
System.out.println("teacher");
}
}
public class Student extends Person{
//重写了父类的run
public void run()
{
System.out.println("student run");
}
public void StudentEat()
{
System.out.println("eat");
}
}
instanceof
-
用于判断一个对象是什么类型的(判断有没有类的继承关系)
public class Person { public void run() { System.out.println("run"); } }
public class Student extends Person{ //重写了父类的run public void run() { System.out.println("student run"); } public void eat() { System.out.println("eat"); } }
public class Teacher2 extends Person{ void print() { System.out.println("teacher"); } }
public class Demo { static public void main(String[] args) { //x instanceof Y能不能编译通过看两者有没有关系,是ture就有继承关系,是false就同级 //Object>Person>Student //Object>Person>Teacher //Object>String Object s1=new Student(); System.out.println(s1 instanceof Object); //有继承关系,输出true System.out.println(s1 instanceof Person); //有继承关系,输出true System.out.println(s1 instanceof Student); //有继承关系,输出true System.out.println(s1 instanceof String); //有继承关系,输出true System.out.println(s1 instanceof Teacher); //有继承关系,输出true Person s2=new Student(); System.out.println(s2 instanceof Object); //有继承关系,输出true System.out.println(s2 instanceof Person); //有继承关系,输出true System.out.println(s2 instanceof Student); //有继承关系,输出true System.out.println(s2 instanceof Teacher2); //student和teacher同级 输出false // System.out.println(s2 instanceof String); //编译报错,没有关联 System.out.println(); Student s3=new Student(); System.out.println(s3 instanceof Object); //有继承关系,输出true System.out.println(s3 instanceof Person); //有继承关系,输出true System.out.println(s3 instanceof Student); //有继承关系,输出true // System.out.println(s3 instanceof String); //无关 编译报错 // System.out.println(s3 instanceof Teacher2); //无关 编译报错 } }
object类
常用方法
方法名称 | 方法说明 |
---|---|
equals() | 指示其他某个对象是否与此对象"相等" |
getClass() | 返回Object的运行时类 |
hashCode() | 将对象的内存地址进行哈希运算,返回int类型的一个值 |
toString() | 返回该对象的字符串表示 |
匿名内部类
-
在定义匿名内部类的地方往往直接创建一个该类的对象
public class Demo { public static void main(String[] args) { //定义一个内部类Cat实现Animal接口 class Cat implements Animal{ //实现shout方法 @Override public void shout() { System.out.println("miao~"); } } animalShout(new Cat()); } //定义静态方法 //内部类Cat实现了Animal接口,在调用animalShout()方法时,将Cat类的实例对象作为参数传入方法中 public static void animalShout(Animal an){ an.shout();//调用传入对象an的shout方法 } }
public interface Animal {
void shout();
}
5异常
Error&Exception
-
检查性异常:最具代表性的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略
-
运行时异常:
- 运行时异常可以在编译时被忽略
- 一般由程序逻辑错误引起,可以被捕获
-
错误Error:
- 错误不是异常,而是脱离程序员控制的问题,在编译时也检查不到的
- Error类对象由Java虚拟机生成并抛出,大多数错误与代码编写者所执行的操作无关。
- 是灾难性的错误,一般JVM会选择终止线程
异常体系结构
-
Java把异常当作对象类处理,并定义一个类java.lang.Throwable作为所有异常的超类
-
异常类分为两大类,错误Error和异常Exception
异常处理机制
-
抛出异常
-
捕获异常
-
异常处理五个关键字
-
try
-
catch
- 捕获异常,括号里是捕获异常的类型,类型级别可以参考体系结构
- 可以写多个,级别按从上到下的顺序从小到大写
-
finally
//idea快速生成:ctrl+alt+t public class demo1 { public static void main(String[] args) { int a=1; int b=0; try{//try监控区域 System.out.println(a/b); }catch (ArithmeticException e){//catch捕获异常,里面的参是想要捕获的异常类型 System.out.println("程序出现异常,变量b不能为0"); e.printStackTrace();//打印错误的栈信息 }finally {//处理善后工作。可有可无,但是关闭的操作一般放在finally里面 System.out.println("finally"); } } }
-
throw
-
throws
public class demo1 { public static void main(String[] args) { try { new demo1().test(1,0); } catch (Exception e) { e.printStackTrace(); } } public void test(int a,int b){ if(b==0){ throw new ArithmeticException();//主动抛出异常 } //即使没有这行也会抛出异常 System.out.println(a/b); } }
自定义异常
-
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外,用户还可以自定义异常。用户自定义异常类,只需继承Exception类即可
-
在程序中使用自定义异常类,大体可分为以下几个步骤:
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常对象
3.如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作。
4.再出现异常方法的调用者中捕获并处理异常
public class MyException extends Exception{ //传递数字>10就抛出异常 private int detail; public MyException(int a){ this.detail=a; } public String toString(){ return "MyException"+detail; } }
public class Test { //可能会存在异常的方法 static void test(int a)throws MyException{ if(a>10){ throw new MyException(a);//抛出异常 } System.out.println("ok"); } public static void main(String[] args) throws MyException { try { test(11); } catch (MyException e) { //e.printStackTrace(); System.out.println("MyException"+e); } } }
经验总结
- 处理运行异常时,采用逻辑去合理规避同时辅助try-catch处理
- 在多重catch块后面,可以加一个catch(Exception)来处理可能会被遗漏的异常
- 对于不确定的代码,可以加上try-catch,处理潜在的异常
- 尽量去处理异常,切忌只是简单地调用printStackTrace()去打印输出
- 具体如何处理异常,要根据不同的业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源
-
内容总结
以上是互联网集市为您收集整理的Java面向对象进阶全部内容,希望文章能够帮你解决Java面向对象进阶所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。