本文详细介绍了Java中的面向对象特性，如封装、静态、代码块、权限修饰符、继承、super关键字、重写与重载的区别、final关键字、抽象类、接口和多态。同时，讲解了异常处理的概念，包括如何使用try-catch-finally进行异常捕获，以及instanceof关键字的作用。通过对这些基础知识的深入理解，有助于提升Java编程能力。
面向对象进阶
一、封装private
- 在开发中， 为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作
二、static
- static表示“静态”的意思，可以用来修饰成员变量和成员方法
- static的主要作用在于创建独立于具体对象的域变量或者方法
简单理解： 被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。并且不会因为对象的多次创建 而在内存中建立多份数据。
- 通俗的解释：静态隶属于类直接管理，引用静态的方法或者变量就是不用再去new一个新对象，直接可以 类.变量/方法 即可
- 除此之外，在写代码中可以方便简写在程序中不变的量
比如：在北京工作的人工作地点都是北京 那么该对象都可以以静态区写 方便同意修改不用一步一步改
重点：
- 静态成员 在类加载时加载并初始化。
- 无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用
- 在访问时： 静态不能访问非静态 , 非静态可以访问静态 !
通俗的解释：你爸和你妈结婚之后才有的你，在结婚之前你妈没有办法找到你，但是结婚后有了你，你不管在那个步骤都可以找到你妈（你是非静态，你妈是静态）
三、代码块
-
普通代码块
在执行的流程中 出现的 代码块， 我们称其为普通代码块。 -
构造代码块（在类中没与任何的前缀或后缀,并使用"{}"括起来的代码片段）
在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。 -
静态代码块
在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭 ，只会
执行一次的代码块。 -
同步代码块
-
面试题：
构造方法 与 构造代码块 以及 静态代码块的执行顺序：
静态代码块 --> 构造代码块 --> 构造方法
四、权限修饰符
- public：表示公共的内容，可以被所有操作所调用
五、继承
- 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法或者子类从父类继承方法，使子类具有父类相同的行为。
通俗的讲：你爹有的特征行为，你都可以拥有。但是你可以再你爹给你的这些特征行为的基础上有新的特征基础。应用到代码中就是子类可以通过继承调用父类的属性和方法（好处就是减少了代码的重复性）
public class Demo5 {
public static void main(String[] args) {
Student student = new Student();
student.setName("乔一成");
student.getAge(18);
student.say();
}
}
class Person{
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge(int i) {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void say(){
System.out.println("我是："+name+",我今年"+age+"岁了");
}
}
class Student extends Person{
}
- 继承的限制：Java只有单继承，没有多重继承。也就是说如果想要继承多个，排排序一个一个先去继承上一个最后的就是继承了完整的。
子类实例化：
就是子类获取父类的地址
注意权限修饰符：public protected能在父类子类使用
六、super
- 通过super可以访问父类的构造方法，属性，方法。
- 调用super构造方法的代码必须要写在子类构造方法的第一行
super往往通过无参自动去找，也可以被省略。super也可以传参哦
七、重写，重载的区别
- 重写：当子类继承了父类，子类有选择的权力去重新写一种自己的方法
- 重写规则：
1.参数列表必须要完全与被重写方法相同
2.返回值的类型必须完全与被重写的方法的返回值类型相同
3.访问权限不能比父类中被重写的方法访问权限更低
4.父类的成员方法只能被他的子类重写
5.声明为static和private的方法不能被重写但是可以被再次声明.
public class Demo5 {
public static void main(String[] args) {
Student student = new Student();
student.say();
}
}
class Person{
public void say(){
System.out.println("我是人");
}
}
class Student extends Person{
public void say(){
System.out.println("我是人类中的学生");
}
}
------------------------------------------------------
我是人类中的学生
参数列表必须要完全与被重写方法相同
如果父类不传参，但是子类传参了，依然调用父类的方法
public class Demo5 {
public static void main(String[] args) {
Student student = new Student();
student.say();
}
}
class Person{
public void say(){
System.out.println("我是人");
}
}
class Student extends Person{
public void say(String test){
System.out.println("我是人类中的学生");
}
}
-----------------------------------------------------
我是人
- 重写（Override）和重载（Overload）的区别：
1.发生的位置：
重载：一个类中
重写：子父类中
2.参数的列表限制：
重载：必须不同
重写：必须相同
3.返回值类型：
重载：与返回值类型无关
重写：返回值类型必须一致
4.访问权限：
重载：与访问权限无关
重写：子的访问权限不能低于父的访问权限
5.异常处理：
重载：与异常无关
重写：异常范围可以变小但不能抛出新的异常
八、final
- final关键词用于修饰属性，变量
修饰过后变量成为了常量并且不能对其进行赋值 - 全局常量（public static final）：任何位置都可以使用这个常量
- final关键词修饰类
不能被继承 - final关键词修饰方法
不能被子类重写
九、抽象类
通俗的解释：如果把人作为最大的父类，把他比作抽象类那么其中有一种行为是人可以说话。但是人可以分为很多种：学生，护士，警长。大家都会说话，但是大家说的内容都是不一样的们对于每个人而言他们说的都都会具体。但是对人大类来说，说话却包含了太多相对比较抽象模糊。当子类要明确自己说什么话就是实体化。
- 在抽象类的使用中有几个原则：
抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全部抽象方法。
public class Demo5 {
//格式：
abstract class Person{
//注意 抽象方法只声明不实现 就是后面没有大括号
public abstract void say();//{
// }
}
}
public class Demo5 {
abstract class Person{
public abstract void say();
}
//1.子类继承抽象类要么在类名前面加abstract
public abstract class Student extends Person{
}
//2.或者重写方法，也就是实体化抽象类
public class Nurse extends Person{
public void say() {
}
}
}
- 常见问题
1、 抽象类能否使用final声明？
不能，因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能。
2、 抽象类能否有构造方法？
能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默认是无参的），之后再调用子类自己的构造方法。（构造方法不能被程序员创建，但是可以被Java虚拟机创建）
public class Demo5 {
abstract class Person {
public Person() {
System.out.println("这是构造方法");
}
public abstract void say();
}
public class Student extends Person {
@Override //这是重写的注解 作用是去检查是不是父类有的方法
public void say() {
System.out.println("我是学生");
}
}
public class Nurse extends Person {
public void say() {
System.out.println("我是护士");
}
}
}
- 抽象类和普通类的区别
1、抽象类必须用public或protected修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）默认缺省为 public
2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化。
3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类
十、接口
- 目的：
降低程序的耦合性
易于程序的扩展
有利于程序的维护 - 接口只能是抽象类（抽象类里面可以包括抽象类和实体类）或者全局常量
接口不能有可实现的内容 意思就是不能有大括号
//格式：
interface 接口名称{
全局常量 ;
抽象方法 ;
}
- 因为接口本身都是由全局常量和抽象方法组成 ， 所以接口中的成员定义可以简写：
1、全局常量编写时， 可以省略public static final 关键字，例如：
public static final String INFO = “内容” ;
简写后：
String INFO = “内容” ;
2、抽象方法编写时， 可以省略 public abstract 关键字， 例如：
public abstract void print() ;
简写后：
void print() ;
public interface Demo6 {
int a = 10;//public static final int a = 10;
String b ="123";//public static final String b = "123"
void say();//public abstract void say();不能加{}
}
-
接口可以多实现：
格式：
class 子类 implements 父接口1,父接口2…{
}
以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写即可：
class 子类 extends 父类 implements 父接口1,父接口2…{
} -
接口因为都是抽象部分， 不存在具体的实现， 所以允许多继承,例如：
interface C extends A,B{
} -
如果一个接口要想使用，必须依靠子类。 子类（如果不是抽象类的话）要实现接口中的所有抽象方法。
-
接口和抽象类的区别：
1、抽象类要被子类继承，接口要被类实现。
2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
4、抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现
5、抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）
6、接口不能有构造方法，但是抽象类可以有
十一、多态
- 多态：就是对象的多种表现形式，（多种体现形态）
- 通俗解释：把人作为父类，子类可以是护士学生等等。这种概念叫做多态。
- 对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态 ，对象多态性就从此而来。
ps: 方法的重载和重写也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。
重载： 一个类中方法的多态性体现
重写： 子父类中方法的多态性体现。
-
多态的使用：对象的类型转换
类似于基本数据类型的转换：· 向上转型：将子类实例变为父类实例
|- 格式：父类 父类对象 = 子类实例 ；· 向下转型：将父类实例变为子类实例
|- 格式：子类 子类对象 = （子类）父类实例
public interface Person {
void say();//public abstract void say();不能加{}
}
public class Student implements Person{
@Override
public void say() {
System.out.println("我是学生");
}
public class Teacher implements Person{
@Override
public void say() {
System.out.println("我是老师");
}
public class Demo5 {
//父类引用指向子类
public static void main(String[] args) {
Student student = new Student();
Teacher teacher = new Teacher();
Person person1 = student; //把学生叫做人
Person person2 = teacher; //把老师叫做人
person1.say();
person2.say();
Student student1 = (Student) person1;//把人叫做学生 父类转向子类要强转
//不能把学生叫成老师
student1.say();
}
-----------------------------------------------------
我是学生
我是老师
我是学生
public class Demo5 {
public static void main(String[] args) {
Student student = new Student();
student.say();
Teacher teacher = new Teacher();
teacher.say();
}
//当我们在写新程序时 12-14的代码可以不动 把person父类模糊化 不管我们要学生还是老师 给或者我们要新的任务 都可以直接重写 更加方便
public static void say(Person person){
person.say();
-------------------------------------
我是学生
我是老师
}
}
十二、instanceof
- 作用：
判断某个对象是否是指定类的实例，则可以使用instanceof关键字
防止老师被说成学生或者学生被说成老师进行提前判断 - 格式：
实例化对象 instanceof 类 //此操作返回boolean类型的数据
十三、内部类
-
在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类
-
内部类可分为4种：
1、成员内部类
2、局部内部类
3、匿名内部类
4、静态内部类 -
成员内部类
特点： 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法
public class Demo6 {
//外部类
public static class Outer{
private int a =10;
private int b =20;
public int getA() {
return a;
}
public void setA(int a) {
this.a = a;
}
//内部类
class Inner{
private int a = 30;
public void say(){
System.out.println(a);//如果内部类和外部类同时有一个属性 优先打最近的那个也就是内部类的
System.out.println(Outer.this.a);//打印外部类的格式
System.out.println(b);//内部类可以直接使用外部类的所有东西 概念顺序就是外部类的所有属性都被创建了 才有内部类
}
}
}
}
public class Test {
public static void main(String[] args) {
Demo6.Outer o = new Demo6.Outer();
Demo6.Outer.Inner i = o.new Inner();
i.say();
}
}
------------------------------------------------------------
30
10
20
- 局部内部类
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。
局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。
public class Demo7 {
//方法：
public static void main(String[] args) {
//局部内部类
class PersonImp implements Person{
@Override
public void say() {
System.out.println("我是局部内部类 我的父类是Person");
}
}
PersonImp personImp = new PersonImp();
haha(personImp);
}
//当我们要去写新的东西的时候 但是他的父类是person 而且这个方法只需要调用一次我们就可以通过局部内部类去实现
public static void haha(Person person){
}
}
- 匿名内部类
没有名字，一般不会使用第二次
public class Demo7 {
//方法：
public static void main(String[] args) {
//匿名内部类
Person person = new Person() {
public void say(){
System.out.println("我是匿名内部类");
}
};
haha(person);
}
public static void haha(Person person){
}
}
-
在使用匿名内部类的过程中，我们需要注意如下几点：
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或
者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
6、只能访问final型的局部变量 -
静态内部类
定义在另一个类里面的类，只不过在类的前面多了一个关键字static。
静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法.
public class Test {
public class Book{
private String name = "123";
private static int a = 1;
//静态内部类
static class Infor{
public void say(){
//这里面静态内部类可以访问第加了静态的a 但是不能访问name
System.out.println("我是静态内部类");
}
}
}
public static void main(String[] args) {
Book.Infor infor = new Book.Infor();
infor.say();
}
}
十四、异常处理
- 异常指的是Exception ， Exception类， 在Java中存在一个父类Throwable（可能的抛出）
Throwable存在两个子类：
1.Error：表示的是错误，是JVM发出的错误操作,只能尽量避免，无法用代码处理。
2.Exception：一般表示所有程序中的错误，所以一般在程序中将进行try…catch的处理。
- 异常分为两类：
1.受检查的异常：写的时候有错就会漂红
2.不受检查的异常：写的时候不会提示，但是运行的时候会报错
- 异常处理基本格式以及概念
try {
//有可能发生异常的代码段
}catch(异常类型1 对象名1){
//异常的处理操作
}catch (异常类型2 对象名2){
//异常的处理操作2
} finally {
//必然执行的异常统一处理出口
//无论是否发生异常, finally必然执行.
}
}
- 可以看出，除数不能为0否则会有异常 那么针对有可能发生的问题我们都要去进行异常的判断。
public static void main(String[] args){
haha();
System.out.println("程序执行完毕 , 正常结束");
}
private static void haha() {
try {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个数字");
int x = input.nextInt();
System.out.println("请再输入一个数字");
int y = input.nextInt();
System.out.println(x / y);
System.out.println("处理完毕");
}catch(Exception e){//多态
System.out.println("输入有误");
}finally {
//必然执行的异常统一处理出口
//无论是否发生异常, finally必然执行.
System.out.println("213123");
}
}
}
- 异常检查的顺序
一开始先由各种方法本体去找秒如果明确了有误先自己处理，如果相对应方法不去处理，那就给调用这个方法的函数去处理，如果他也不处理就会反馈给JVM，因为他是老大，他就是一开始找到错误的，他也是让程序自己去解决的，如果都不去处理他就报错。
-
异常的类型
通过JDK去查找，但是一般找不到指定的，我们通常使用范围最大的RuntimeException去处理异常。 -
面试题
- try-catch-finally 中哪个部分可以省略？
答： catch和finally可以省略其中一个 ， catch和finally不能同时省略
注意:格式上允许省略catch块, 但是发生异常时就不会捕获异常了,我们在开发中也不会这样去写代码. - try-catch-finally 中，如果 catch 中 return 了，finally 还会执行吗？
答：finally中的代码会执行
详解：
执行流程：- 先计算返回值， 并将返回值存储起来， 等待返回
- 执行finally代码块
- 将之前存储的返回值， 返回出去；
需注意：
- 返回值是在finally运算之前就确定了，并且缓存了，不管finally对该值做任何的改变，返回的值都不
会改变 - finally代码中不建议包含return，因为程序会在上述的流程中提前退出，也就是说返回的值不是try或
catch中的值 - 如果在try或catch中停止了JVM,则finally不会执行.例如停电- -, 或通过如下代码退出
JVM:System.exit(0);
扫一扫
173
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
