❤️什么是Java 面向对象《装、继承、多态、抽象》？建议收藏）❤️

系统管理员 2023-10-04 11:26 2阅读 0赞

## Java 面向对象（详解） ##

##### 一、面向对象 #####

（1）.面向对象编程（Object-Oriented Programming，OOP）

（2）.面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据

（3）.面向对象是一种抽象的，具有主要的特征分别是封装、继承、多态、抽象

#### 二、构造器（创建与初始化对象） ####

（1）.使用new关键字创建对象）

（2）.使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

（3）.类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

1.必须和类的名字相同

2.没有返回类型，也不能写void

构造器必须掌握！！！在下面的代码示例中我们可以看到构造器的使用！！！

--------------------

##### 1、封装 #####

是将东西包围起来通过自己想定义的方式获取。把过程和数据包围起来，对数据的访问只能通过已定义的界面。

代码示例：

package oop.Demo01;
    //OopDemo01  类
    public class OopDemo01 {
        
        //main方法
        public static void main(String[] args) {
        
            
            System.out.println(max(10,50));//50
            int max=OopDemo01.max(10, 100);
            System.out.println(max);//100
        }
        /*
        修饰符 返回值类型  方法名（...）
        //方法体
        //return 返回值
        */
        public String sayHello(){
        
            return "Hello World";//return 方法 返回一个结果
        }
        public static int max(int a,int b){
        
            return a>b?a:b;
        }
    
    }

###### 2、继承： ######

是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。使用关键字为extends

代码示例：

//子类：继承了父类，拥有父类的全部方法
    package oop.Demo05;
    //继承关系
    //A extends B 父子关系   A是子类  B是父类  
    //子类A继承父类B
    public class A extends B{
        
        public static void main(String[] args) {
        
            A a=new A();
            a.test();//走的是A类的方法 输出A->test()
    
            //父类的引用指向了子类
            B b=new A();
            b.test();//走的是A类的方法 输出A->test()
    
            B c=new B();
            c.test();//走的是B类的方法 输出B->test()
    
           
        }
        //重载是本类
        //重写是子父类才有的
        //Override重写的意思
        @Override  //注解：有功能的注解！
        public void test() {
        
    
            System.out.println("A->test()");
        }
        
    }

//父类
    package oop.Demo05;
    public class B {
        
    public void test(){
        
    
            System.out.println("B->test()");
        }
    }

###### 注意点： ######

子类重写了父类的方法，刚才输出A B的时候是静态方法 static，静态方法与非静态方法的区别很大，静态方法;方法的调用只和左边，与定义类型有关，非静态方法：需要进行重写，重写的关键词只能是public 不能是private.若将public修改为private 则super不可调用,私有的不可被继承

super注意点：
    1.super 调用父类的构造方法，必须在构造方法的第一个
    2.super 必须只能出现在子类的方法或者构造方法中
    3.super和this 不能同时调用构造方法
    4.调用了父类的无参构造---super（）；这段代码时隐藏的
      public Student() {
        
            //而且如果要显示super（）；
            //调用父类的构造器，必须要在子类的第一行
            //this();也是一样  否则报错
            super();
            System.out.println("Student无参执行");
        }
    
    super与this对比
    一、代表的对象不同：
            1.this 本身调用这个对象
            2.super 代表父类对象的引用
    二、前提：
           1.this 没有继承也可以使用
           2.super 在继承条件下才可以使用
    三、构造方法：
           1.this（） 本类的构造
           2.super（） 父类的构造
    
    
    重写：需要有继承关系，子类重写父类的方法
       1.方法名必须相同
       2.参数列表必须相同
       3.修饰符：范围可以扩大,但不能缩小 public>protected>default>private
       4.抛出的异常：范围可以被缩小，但不能被扩大 ClassNotFoundException--->Exception（大）
       重写；子类的方法和父类的方法必须一致，方法体不同！
    
       为什么需要重写？
       1.父类的功能  子类不一定需要 或者不一定满足！
        
       重写快捷方法
       1.alt+insert： 选中overring即可重写

###### 3、抽象： ######

就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象包括两个方面，一是过程抽象，二是数据抽象。关键字为：sbstract

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类是抽象的，是对对象的抽象

从代码运行角度考虑是先有类后有对象，类是对象的模板

代码示例：

package oop.Demo08;
    //抽象类的所有方法  继承了它的子类 都必须要实现它的方法 除非加上abstract
    public abstract class A extends Action{
        
    
        public void doSomething(){
        
    
        }
    
    
    }

package oop.Demo08;
    //在一个类上面加上abstract即变成抽象类
    //java的类是单继承
    //但是接口可以是多继承
    public abstract class Action {
        
        
        public abstract void doSomething();
       
    
    }

###### 注意点： ######

1.abstract 抽象方法，只有方法名字，没有方法的实现。不能new这个抽象类只能靠子类去实现它！因为具有约束条件！

2.抽象类中可以写普通方法，抽象方法必须存在抽象类中

3.存在的意义：抽象出来，提高开发效率

###### 4、多态 ######

即同一方法可以根据对象的不用而采用多种不用的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

多态存在的条件:

1.有继承关系

2.子类重写父类的方法

3.父类引用指向子类对象

注意点：多态是方法的多态，属性没有多态。

代码示例：

//第一个java类
    package oop.Demo06;
    
    public class Application01 {
        
        public static void main(String[] args) {
        
            //一个对象的实际类型是确定的
            //new Student();
            //new person();
            //当可以指向的引用类型就不确定了
            // Student能调用的方法都是自己的或者继承父类的
            Student01 s1=new Student01();
            // Person父类型，可以指向子类，但是不可以调用子类独有的方法
            Person01 s2=new Student01();  //父类的引用指向子类的
            // Object s3=new Student01();
    
            s2.run();
            //子类重写了父类的方法，执行了子类的方法
            s1.run();
    
            //对象能执行哪些方法，主要看对象 左边的类型，和右边关系不大！
            //s2.eat();  //子类重写了父类的方法，执行子类的方法
            ((Student01)s2).eat();//强转换类型，将s2强制转换位student类型
            s1.eat();
    
    
        }
    }

//第二个java类
    package oop.Demo06;
    
    public class Person01 {
        
       public  void run(){
        
        
        }
    }

//第三个java类
    package oop.Demo06;
    
    public class Student01 extends Person01 {
        
    //这里Student01继承了父类Person01的方法
      public void run() {
        
            System.out.println("son");
        }
    
        public void eat(){
        
            System.out.println("eat");
         }
    }

#### 三、instanceof（类型转换）引用类型 ####

作用：判断一个对象是什么类型.

代码示例：

//第一个java类
    package oop.Demo06;
    import oop.Demo05.Person;
    public class Application02 {
        
        public static void main(String[] args) {
        
            //1.类型之间的转换： 之前是基本类型转换  满足这个高低 64 32 16 8  低转高则强制
            //2.类型之间的转换：父（高）  子（低）
            //高--->低    不需要强制转换
             // Object>String
            // Object>Person>Teacher
            // Object>Person>Student
            Object object=new Student02();
           // System.out.println(X instanceof Y);//能不能编译通过 取决于X与Y之间是否存在父子关系
            System.out.println(object instanceof Student02); //true
            System.out.println(object instanceof Person02); //true
            System.out.println(object instanceof Object); //true
            System.out.println(object instanceof Teacher);//false
            System.out.println(object instanceof String);//false
            System.out.println("==============================================");
            Person02 person02=new Student02();
            System.out.println(person02 instanceof Student02); //true
            System.out.println(person02 instanceof Person02); //true
            System.out.println(person02 instanceof Object); //true
            System.out.println(person02 instanceof Teacher);//false
            //System.out.println(person02 instanceof String);//编译报错
            System.out.println("==============================================");
            Student02 student02=new Student02();
            System.out.println(student02 instanceof Student02); //true
            System.out.println(student02 instanceof Person02); //true
            System.out.println(student02 instanceof Object); //true
    
    
        }
    }
    /*
    父类指向子类的对象
    把子类转换为父类，向上转型 （不用强制转换）
    把父类转换为子类，向下转型  （需要强制转型）
    方便方法的调用 减少重复的代码 简洁
    抽象：编程思想
    抽象 封装 继承 多态 ！  抽象--> 接口
     */

//第二个java
    package oop.Demo06;
    
    public class Person02 {
        
    }

//第三个java
    package oop.Demo06;
    
    public class Student02 extends Person02 {
        
     
    }

##### 四、三种构造器 #####

匿名构造器、静态构造器、方法构造器

以下为代码示例：

package oop.Demo07;
    //Person被final定义了  则不能被继承 public final class Person
    public class Person {
        
    
         //匿名构造器
        {
        System.out.println("匿名代码块");}
        
        //静态构造器 只执行一次
        static{
        System.out.println("静态代码块"); }
    
       public Person(){
        System.out.println("构造器方法");}
    
       public static void main(String[] args) {
        
            Person person1=new Person();
            //输出结果：静态代码块  静态代码块 静态代码块
            System.out.println("=========================");
            Person person2=new Person(); 
             //静态构造器 只执行一次
            //输出结果：匿名代码块 构造器方法
    
        }
    }

注意点：在java中是值传递的，代码示例：

package oop.Demo01;
    
    public class OopDemo04 {
        
        public static void main(String[] args) {
        
            int a=1;
            System.out.println(a);//1
    
            OopDemo04.change(a);//无输出结果
    
            System.out.println(a);//1
    
    
        }
        
        //这里的返回值为空  回到主函数
        public static void change(int a){
        
            a=10;
    
        }
    }

#### 五、接口 ####

普通类：只有具体实现

抽象类：具体实现和规范（抽象方法）都有！

接口：只有规范！（自己无法写方法~专业的约束！）

代码示例：

//第一个java类
    package oop.Demo09;
    
    public interface TimeService {
        
        void timer();
    }

//第二个java类
    package oop.Demo09;
    //interface  定义的关键字 接口都需要实现类
    public interface UserService {
        
        //定义常量---public static final
        int age=99;
    
       //接口中的所有定义都是抽象的
       // 而且都是piblic abstract  若是不写默认都是piblic abstract
       // public  abstract void run();
        void add(String name);
        void delete(String name);
        void update(String name);
        void query(String name);
    }

//第三个java类	
    package oop.Demo09;
    //抽象类：extends只能单继承
    //类可以实现接口   implements  接口 可以多继承
    //实现了接口中的类  就需要重写接口中的方法
    // UserService,TimeService实现了多继承
    //利用接口实现多继承
    //接口里边只有方法的定义没有方法的使用
    public class UserServiceImpl implements UserService,TimeService{
        
        @Override
        public void add(String name) {
        
    
        }
    
        @Override
        public void delete(String name) {
        
    
        }
    
        @Override
        public void update(String name) {
        
    
        }
    
        @Override
        public void query(String name) {
        
    
        }
        
        @Override
        public void timer() {
        
    
        }
    }

#### 六、内部类 ####

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类

类别：

1.成员内部类

2.静态内部类

3.局部内部类

4.匿名内部类

//第一个java类
    package oop.Demo10;
    
    public class Application {
        
        public static void main(String[] args) {
        
             Outer outer=new Outer();
              //使用内部类
              //通过这个外部类来实例化内部类
            Outer.Inner01 inner01=outer.new Inner01();
            inner01.in();//输出这是内部类的方法
            inner01.getID();//输出99
    
        }
    }

//第二个java类
    package oop.Demo10;
    
    public class Test {
        
        public static void main(String[] args) {
        
    
            //匿名类
            //没有名字初始化类 ,不用将实例保存到变量中
            new Apple().eat();
    
           //Apple apple=new Apple();   new一个实例化对象
    
            UserService userservice=new UserService(){
        
                //没有名字初始化 需要重写
                @Override
                public void Hello() {
        
    
                }
            };
        }
    
    }
    
    class Apple{
        public void eat(){
        
            System.out.println("Apple");
        }
    
    }
    interface  UserService{
        
        void Hello();
    }

//第三个java类
        package oop.Demo10;
        
        public class Outer {
        
            private int id=99;
            public void out(){
         System.out.println("这是外部类的方法"); }
        
            public class Inner01{
        
                public void in(){
        
                    System.out.println("这是内部类的方法");
                 }
        
                //获得外部类的私有属性
                //加上static（ public static class Inner）之后 这个id就拿不到了 若想要拿到 则 private static int id=99;即可
                 public  void getID(){
        
                   System.out.println(id);
               }
        
               //局部内部类
             public void method(){
        
                     class Inner02{
        
                         public void in(){
        
        
                            }
        
                   }
               }
       }
            
                   
    }
        
        //一个java类中 可以有多个class类
        //但是只能有一个public class类
        class A{
        
            public static void main(String[] args) {
        
                System.out.println("你好");
            }
        
        }