面向对象是一种抽象的程序设计方式，具有封装、多态和继承三大特征。

封装性

封装可以增加代码的安全性，防止外部对内部代码的破坏。

JAVA可以通过权限关键字设置成员方法和成员变量的访问权限。

  • private：私有的，只允许在本类内部访问，如果构造方法被设置为private则该方法不能被实例化
  • default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
  • protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
  • public：类中限定为public的成员，可以被所有的类访问。

    构造方法

    构造方法为与类同名的方法，当实例化对象是首先调用构造方法，构造方法没有返回值，用于给成员变量初始化，可以同时拥有多个参数不一样的构造方法。

    无参构造方法

    1. public class test1 {
    2.   public test1(){
    3.       System.out.println("这是无参构造方法");
    4.   }
    5. }
    6. /*当没定义构造方法时默认调用无参构造方法*/

    有参构造方法

    1. public class test1 {
    2.   public test1(String a){
    3.       System.out.println("这是有参构造方法");
    4.   }
    5. }
    6. /*当有多个参数时使用逗号分隔参数*/

    this关键字

    this关键字可以用来调用本类中的成员变量，成员方法和构造方法。this关键字只能在构造方法中使用。

    调用成员变量

    1. public class test1 {
    2.   String name;
    3.   public test1(String name){
    4.       this.name = name;
    5.   }
    6. }
    7. /* 将形参name赋值给成员变量name */

    调用成员方法

    1. public class test1 {
    2.   String name;
    3.   public test1(String name){
    4.       this.show();
    5.   }
    6.   public void show(){
    7.       System.out.println("调用本方法");
    8.   }
    9. }

    调用构造方法

    1. public class test1 {
    2.   String name;
    3.   public test1(){
    4.       System.out.println("这是无参构造方法");
    5.   }
    6.   public test1(String name){
    7.       this();
    8.   }
    9. }
    10. /* 当使用this调用构造方法时必须写在第一行 */

继承

继承可以 让子类继承父类的方法和属性，提高代码的复用性和便于维护。

extends

  1. public class test1{
  2.     String name = "test1";
  3.     int age = 10;
  4. }
  7. public class test2 extends test1{
  9. }
  10. /*test2类继承test1类并且拥有test1类中的name和age成员变量*/

方法重写

在JAVA中，子类可以原封不动继承父类的方法，当子类方法需要改动时也可以在子类中重新编写方法即方法重写。

  1. public class test1 {
  2.     public void dog(){
  3.         System.out.println("黑狗");
  4.     }
  5. }
  6. public class test2 extends test1{
  7.     public void dog(){
  8.         System.out.println("黄狗");
  9.     }
  10. }
  11. /*
  12. 1.发生在子父类中，方法重写的两个方法返回值、方法名、参数列表必须完全一致（子类重写父类的方法）
  13. 2.父类中的方法若使用private、static、final任意修饰符修饰，那么，不能被子类重写。
  14. */

super

super关键字可以调用父类的方法和属性

  1. public class test1 {
  2.     String name = "name";
  3.     int age = 10;
  4. }
  5. public class test2 extends test1{
  6.     String name = "test2";
  7.     public void show(){
  8.         System.out.println(this.name);
  9.         System.out.println(super.name);
  10.     }
  11. }
  12. public class test3{
  13.     public static void main(String[] args) {
  14.         test3 a = new test3();
  15.         a.show();
  17.     }
  18. }
  19. /*
  20. 控制台输出：test2
  21.             name
  22. */
  24. /* 子类中重新赋值成员变量时，使用super关键字可以调用父类中的成员变量*/

抽象类

很多具有相同特征和行为的对象可以抽象为一个类；很多具有相同特征和行为的类可以抽象为一个抽象类。
使用abstract关键字声明的类为抽象类

  1. public abstract class test1{
  2.     public abstract void animal();
  3. }
  4. public class test2 extends test1 {
  5.     public void animal(){
  6.         System.out.println("这是抽象类实现类");
  7.     }
  8. }
  9. /*
  10. 抽象类可以没有抽象方法，有抽象方法的类必须是抽象类
  11. 非抽象类继承抽象类必须实现抽象类中的所有方法
  12. */

接口

  • 实现接口需要用implements关键字

  • 一个类可以实现多个接口

    1. public interface test1 {
    2.   public abstract void dog();
    3. }
    4. public interface test2{
    5.   public abstract void cat();
    6. }
    7. public class test3 implements test1,test2 {
    8.   public void dog(){
    9.       System.out.println("实现dog接口");
    10.   }
    11.   public void cat(){
    12.       System.out.println("实现cat接口");
    13.   }
    14. }

    状态修饰符

    final

  • 被final修饰的成员变量表示为常量，即不可被二次赋值

  • 被final修饰的成员方法表示为最终方法，不可被重写

  • 被final修饰的类不可以作为父类被子类继承

    static

  • 被static修饰的成员变量和方法可以直接用类名.方法名/变量名进行访问、赋值

  • 被static修饰的成员变量被类的所有对象共享

  • 静态方法只能访问静态成员

    多态

    多态是同一个行为具有多个不同表现形式或形态的能力。
    多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

    1. public interface Animal {
    2.   public void eat();
    3. }
    4. public class Cat implements Animal{
    5.   public void eat(){
    6.       System.out.println("猫吃鱼");
    7.   }
    8. }
    9. public class Dog implements Animal{
    10.   public void eat(){
    11.       System.out.println("狗吃骨头");
    12.   }
    13. }
    14. public class User {
    15.   public void u(Animal a){
    16.       a.eat();
    17.   }
    18. }
    19. public class Demo {
    20.   public static void main(String[] args) {
    21.       User a = new User();
    22.       Animal c = new Cat();
    23.       Animal d = new Dog();
    24.       a.u(c);
    25.       a.u(d);
    26.   }
    27. }
    28. /*将子类实例声明为父类，可以根据实例对象不同调用子类公有的方法，不可调用子类独有的方法*/

    转型

    1. /*向下转型*/
    2. Animal a = new Cat();
    3. /*向上转型*/
    4. Cat c = (Cat)a;

    内部类

    内部类可以访问外部类所有成员包括私有的，外部类访问内部类必须创建对象。

    成员内部类

    1. public class Outer {
    2.   String O_name = "Outer";
    3.   public class Inner{
    4.       String I_name = "Inner";
    5.       public void show(){
    6.           System.out.println(O_name);
    7.       }
    8.   }
    9.   public void show() {
    10.       Inner i = new Inner();
    11.       System.out.println(i.I_name);
    12.   }
    13. }
    14. /*
    15. 内部类调用方式：外部类.内部类 变量名 = new 外部实例.new 外部实例
    16. */

    局部内部类

    1. public class Outer {
    2.   String O_name = "Outer";
    4.   public void method() {
    5.       class Inner {
    6.           public void show() {
    7.               System.out.println(O_name);
    8.           }
    9.       }
    10.       Inner i = new Inner();
    11.       i.show();
    12.   }
    13. }
    14. /*
    15. 局部内部类不能直接访问，只能在方法内部实例化对象调用
    16. */

    匿名内部类

    ```java public interface Inter { public void show(); }

public class Outer { String O_name = “Outer”;

  1. public void method() {
  2.     new Inter(){
  3.         public void show(){
  4.             System.out.println(O_name);
  5.         }
  6.     }.show();
  8. }

}

public class Outer { String O_name = “Outer”;

  1. public void method() {
  2.     Inter i = new Inter(){
  3.         public void show(){
  4.             System.out.println(O_name);
  5.         }
  6.     };
  7.     i.show();
  8. }

} / 匿名内部类本质为继承一个类或实现一个接口 匿名内部类可以通过直接.方法调用也可以赋值调用,赋值变量类型为继承类或接口类型 / ```