目录

文章目录

目录面向对象入门程序继承的特点抽象类抽象类的特点 接口接口的特点 接口和抽象类的区别如何写一个方法呢？两个明确方法的重载方法的重写 成员变量和局部变量的区别在类中的位置不同在内存中的位置不同生命周期不同初始化值不同 静态变量和成员变量的区别内存中所属不同位置不同内存出现时间不同调用不同 final关键字this和super关键字内部类匿名内部类面试题一般内部类静态内部类 多态类中的代码执行顺序

面向对象

入门程序

package object class Circle { double radius; private static final double PI = Math.acos(-1.0); public void setRadius(double givenRadius) { radius = givenRadius; } public double getRadius() { return radius; } public double computeArea() { return radius*radius*PI; } } public class TestCircleParameter { public static void exchangeRadius(Circle first, Circle second) { double tempRadius = first.getRadius(); first.setRadius(second.getRadius()); second.setRadius(tempRadius); } public static void main(String[] args) { Circle circle1 = new Circle(); Circle circle2 = new Circle(); circle1.setRadius(10); circle2.setRadius(20); System.out.println("交换前: "); System.out.println("circle1的半径是:" + circle1.getRadius()); System.out.println("circle2的半径是:" + circle2.getRadius()); exchangeRadius(circle1, circle2); System.out.println("交换后: "); System.out.println("circle1的半径是:" + circle1.getRadius()); System.out.println("circle2的半径是:" + circle2.getRadius()); } }

继承的特点

只支持单继承，不支持多继承java支持多层继承java只能继承父类的非私有的变量（成员变量和成员方法)子类不能继承父类的构造方法，但可以通过super关键字访问父类的构造方法不要为了某些功能而去继承父类

子类都会继承父类的构造方法。无论是系统默认的无参构造还是自定义的有参构造

package object; class X { Y b = new Y(); //第一个Y X() { System.out.print("X"); } } class Y { Y() { System.out.print("Y"); } } class Z extends X { Y y = new Y(); // 第二个Y Z() { //super();默认，供系统底层检查调用，而不具体执行class Z的构造方法 System.out.print("Z"); } } public class Inherit{ public static void main(String[] args) { new Z(); //YXYZ } } package object; class Fu{ public Fu() { System.out.println("我是父类的构造函数"); } public Fu(String name) { System.out.println(name); } } class Zi extends Fu{ public Zi() { System.out.println("我是子类的构造函数"); } public Zi(String name) { System.out.println(name); } } public class InheritWay { public static void main(String[] args) { new Zi(); //每次先读取父类的无参构造方法 new Zi("Hello"); } }

抽象类

抽象类的特点

抽象类和抽象方法必须用abstract关键字修饰抽象类的子类 要么是抽象类要么重写抽象类中的所有抽象方法 抽象类不一定有抽象方法，有抽象方法的类一定是抽象类抽象方法里没有方法体 且不能被final static private修饰抽象类不能实例化那么如何使用抽象类的功能呢? 按照多态的方式使用。抽象类多态。

如果子类是抽象类，可以不用重写父类全部抽象方法。但如果子类不是抽象类，需要重写父类全部抽象方法,若父类有已写出来的有参构造函数，子类也要重写。已写的无参构造函数则不用重写。

接口

接口的特点

接口也可以继承接口，使用关键字extends但是类只能实现接口而不是继承，所以收使用关键字implements多个类可以继承一个接口接口里不能有构造方法接口中的方法默认都是抽象的，默认被public和abstract关键字修饰接口中的方法可以被default修饰，此时该方法具有方法体，即已被实现

接口和抽象类的区别

接口中可以有非抽象的方法,但是该方法一定要被static修饰 即静态方法 直接使用接口名.方法名 调用接口中除了static final变量 不能有其他变量 而抽象类就不一样一个类可以实现多个接口,但是只能继承一个抽象类 接口本身却可以通过关键字extends扩展多个接口接口的默认访问权限修饰为public，default也可以 而抽象类除了private之外的都可以从设计层面来说 抽象是对类的抽象 是一种模板设计 而接口则是对行为的抽象 是一种行为的规范

如何写一个方法呢？两个明确

返回值的类型，明确功能结构的数据类型参数列表，明确有几个参数，及参数的类型

方法的重载

在同一个类中可以允许有相同的方法名，只要他们的参数个数或参数类型不同即可满足重载,但是当参数个数相同时，参数的类型的顺序不可以相同。参数的返回类型可以不一样，访问修饰符可以不一样。在调用时，JVM通过参数列表来区分同名的方法

方法的重写

首先构造方法可以重载，但是不可以被重写重写发生在子类中，重写的是父类中的方法(除了被private和final修饰的方法)重写的方法的修饰符权限不得低于父类重写的方法的返回值必须和父类一致或是父类返回类型的子类重写的方法的方法签名必须和父类保持一致重写方法不得抛出父类没有抛出的异常或者比父类异常范围更大的异常

成员变量和局部变量的区别

在类中的位置不同

成员变量 类中方法外局部变量 方法内或者方法声明上 注：（方法声明上 就是声明方法时的小括号内的形式参数

在内存中的位置不同

成员变量 堆内存局部变量 栈内存

生命周期不同

成员变量 随着对象的存在而存在，随着对象的消失而消失局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

成员变量 有默认的初始化值局部变量 没有默认的初始化值，必须先定义，赋值，才能使用。

如果有同名的变量，一般会采用就近原则。

静态变量和成员变量的区别

内存中所属不同

成员变量属于对象，所以也称为实例变量(对象变量)静态变量属于类，可以被所有的对象共享

位置不同

静态变量属于类，所以也称为为类变量，存储于方法区的静态区成员变量存储于堆内存

内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失成员变量随着对象的创建而存在，随着对象的消失而消失

调用不同

静态变量可以通过类名调用，也可以通过对象调用成员变量只能通过对象名调用

final关键字

final可以修饰类，方法和变量

修饰类时表示该类为最终类不可以被继承，即不可以被重写

修饰方法时表示该方法不可以被重写

修饰变量时，当该变量为基本类型时表示该变量只能被赋值一次，赋值后不能改变。当该变量为引用类型时表示该变量的堆空间的首地址不能再改变，但其内容仍可以改变。

被final修饰的成员变量必须被初始化，要不然最迟在构造方法中被初始化

public class Main { public final int a; public Main(){ a = 6; //正确 被final修饰的成员变量最迟在构造方法中被初始化 } } ---------------------- public class Main { public static final int a; public Main(){ a = 6; //错误 构造函数不可以访问静态变量 静态变量在类加载时被执行，但是构造方法在生成实例对象时才会被加载 } }

this和super关键字

this是一个指向当前对象的指针，可以调用当前对象的成员方法和成员变量，所以可以用来区分局部变量和成员变量super调用父类对象的引用，子类通过super关键字调用父类的构造方法或者成员变量以及成员方法，当调用父类的构造函数时，super()应该写在子类构造函数的第一行this和super指的都是对象，因此不可以在有static关键字的环境中使用

内部类

内部类和他所属的外部类没有继承关系

匿名内部类

前提：存在一个类或接口 该类可以是具体类也可以是抽象类

格式： new 接口名或类名(){ 重写方法(); }

其本质是匿名子类对象

package outer; interface IPerson{ void show(); } class Person{ public void show(IPerson p) { p.show(); } } class Student implements IPerson{ public void show() { System.out.println("匿名对象"); } } public class Outer { public static void main(String[] args) { //匿名内部类做法 new Person().show(() -> System.out.println("匿名内部类")); //匿名内部类 //匿名对象做法 new Person().show(new Student()); //匿名对象 } }

面试题

package outer; interface Inner{ void show(); } class Outer { public void show() { System.out.println("show"); } public static Inner method() { return () -> { System.out.println("重写接口中的方法"); }; } } public class OuterClass_Apply { public static void main(String[] args) { Outer.method().show(); //重写接口中的方法 new Outer().show(); //show } }

一般内部类

package object; class B{ class C{ public void f() { System.out.println("我是内部类中的f方法"); } } } public class ObjectTwo { public static void main(String[] args) { //调用内部类的一般方法 B b = new B(); B.C c = b.new C(); c.f(); //使用匿名对象调用内部类 new B().new C().f(); } }

静态内部类

package outer; interface AA{ void show(); void method(); } class BB implements AA{ public void show(){ System.out.println("我是类BB中的show方法"); } public void method() { System.out.println("我是类BB中的method方法"); } } public class OuterClass implements AA { private int num = 11; public void show() { final int num=10; class Inner{ // int num=10; public void method() { System.out.println(num); //内部类可以直接访问外部类的成员变量 } } Inner i = new Inner(); i.method(); System.out.println(num); } public void method() { AA s = new AA() { public void show() { System.out.println("我是匿名内部类中的show方法"); } public void method() { System.out.println("我是匿名内部类中的method方法"); } }; s.show(); s.method(); } static class CC implements AA{ public void show(){ System.out.println("我是静态内部类CC中的show方法"); } public void method() { System.out.println("我是静态内部类CC中的method方法"); } } public static void main(String[] args) { new OuterClass().show(); //10 10 new OuterClass().method(); //我是匿名内部类中的show方法 我是匿名内部类中的method方法 new BB().show(); //我是类BB中的show方法 new BB().method(); //我是类BB中的method方法 //------------------下面是静态内部类调用方法的两种方法------------------ CC c = new CC(); c.show(); //我是静态内部类CC中的show方法 OuterClass.CC SS= new CC(); SS.show(); //我是静态内部类CC中的show方法 } }

多态

多态是同一种行为具有不同的表现形式或形态的能力

多态发生的条件

继承重写基类引用指向派生类对象（基类是父类，派生类是子类） package object; class Person{ int age = 10; public Person(){ System.out.println("我是父类中的有参构造函数"); } public void sleep() { System.out.println("人要睡觉"); } public void show() { System.out.println("我是父类中的show方法"); } } class Student extends Person{ public Student() { //super(); //子类默认调用父类的无参构造函数，子类的构造函数隐式地调用super() System.out.println("我是子类中的有参构造函数"); } int age = 12; @Override public void sleep() { System.out.println("学生也要睡觉"); } public void show() { System.out.println("我是子类中的show方法"); } public void method(){ System.out.println("我是子类特有的方法"); } } public class DuoTai { public static void main(String[] args) { Person person = new Person(); //我是父类中的有参构造函数 person.sleep(); //人要睡觉 Person student = new Student(); //我是父类中的有参构造函数 我是子类中的有参构造函数 System.out.println(student.age); //10 student.sleep(); //学生也要睡觉 person.show(); //我是父类中的show方法 student.show(); //我是子类中的show方法 } }

成员变量 编译看左边，运行看左边

成员方法 编译看左边，运行看右边。 因为成员方法有重写，而变量没有。

静态方法 编译看左边，运行看左边 静态方法其实没有重写这一说。因为它是跟类相关

但是指向子类的父类引用student却调用不了子类中特有的方法method，所以可以知道多态的缺点是不能使用子类特有的成员属性和子类特有的成员方法

类中的代码执行顺序

静态代码块 --> 构造代码块 --> 构造方法 --> 局部代码块

静态代码块：只执行一次

不加static关键字且定义在类体中的代码块叫做构造代码块

局部代码块就是在方法里面的代码块