JAVA笔记--面向对象

我会带着你远行 2024-04-01 08:40 32阅读 0赞

## 面向对象 ##

#### 什么是面向对象 ####

*  本质：以类的方式组织代码，以对象的组织(封装)数据。
 *  抽象
 *  三大特性：封装、继承、多态
 *  从认识论的角度考虑是先有对象后有类。**对象是具体的事物**，类是对象的抽象。
 *  从代码运行角度考虑是先有类后有对象。**类是对象的模板**。

#### 类与对象的关系 ####

*  类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但并不能代表某一个具体的事物。例如：Person类、Pet类、Cat类等，都是用来描述/定义某一具体的事物应该具备的特点和行为。
 *  对象是抽象概念的具体实例，如张三是人的一个具体实例、张三家里的狗旺财就是狗的一个具体实例。

### 创建与初始化对象 ###

*  使用new来创建对象。
 *  使用new关键字创建的时候，除了分配内存之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。
 *  类中的**构造器**也被称为构造方法，创建对象时必须要调用。有以下特点：**1.必须和类的名字相同。 2.没有返回类型，也不能写void。**
 *  一个类即使什么都不写，也会存在一个默认的构造方法

#### 构造器 ####

public class Person {
        //一个类即使什么都不写，也会存在一个默认的无参构造方法
        //显示地定义构造器
        String name;
        
        //作用：1. 使用new关键字，本质是在调用构造器
        //2. 用来初始化对象的值
        public Person(){} //无参构造
        
        //有参构造 3.一旦定义了有参构造，无参就必须显示定义
        public Person(String name){
            this.name=name;
        }
    	//Alt+insert 快捷键插入构造方法
    }

### 封装 ###

*  我们程序设计要追求“**高内聚，低耦合**”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
 *  封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，称为信息隐藏。
 *  作用：1.提高程序的安全性，保护数据；2.隐藏代码的实现细节；3.统一接口；4.系统可维护性增加了。
    
        //定义一个Student类
        public class Student{
            //运用private定义私有属性
            private String name;
            private int age;
            
            //提供可以操作私有属性的方法 get,set方法
            public String getName(){//get 获取这个值
                return this.name;
            }
            public void setName(String name){//set 设置这个值
                this.name = name;
            }
            public Int getAge(){//get 获取这个值
                return this.age;
            }
            public void setAge(Int age){//set 设置这个值
                this.age = age;
            }
        
        }
    
        //创建个应用类来实现
        public class Appliaction{
            public static void main(String[] args){
                //先实例化对象
                Student s1 = new Student();
                
                s1.setName("小明");
                System.out.println(s1.getName);
            
            }
        
        }
    
    ### 继承 ###
 *  继承的本质是对某一批类的抽象，从而实现对世界更好地建模。
 *  **extends**的意思是”扩展“。子类是父类的扩展，使用关键字extends来表示。
 *  **Java中类只有单继承**，没有多继承！一个类只能继承一个父类。
 *  继承是**类与类之间的一种关系**，此外还有依赖、组合、聚合等。
 *  继承关系的两个类，一个为**子类（派生类）**，一个为\*\*父类（基类）\*\*子类继承父类。
 *  子类和父类之间，从意义上讲应该具有”is a“的关系。

//学生类（子类） 继承 人类（父类） 
    public class Student extends Person{
        //所有类都默认继承Object类
    }

*  子类继承了父类，就会拥有父类的全部方法，而private**私有属性及方法无法继承**。
 *  **被final修饰的类**，无法被继承（断子绝孙）。

#### **super&this** ####

1.  super()调用父类的构造方法，必须在构造方法的第一个
2.  super必须只能出现在子类的方法或构造方法中
3.  \*\*super()**和**this()\*\*不能同时调用构造方法，因为this也必须写在第一行

*  **super与this的区别**：super代表**父类对象的引用，只能在继承条件下使用**；this调用自身对象，没有继承也可以使用。
    
        //定义个Person类，父类
        public class Person{
            protected String name = "小明";
        
        }
    
        //Student类 子类 继承了Person类
        public class Student extends Person{
            private String name = "小红";
            public void test(String name){
                System.out.println(name);//小红
                System.out.println(this.name);//小红
                System.out.println(super.name);//小明
            }
        }
    
        public class Person{
            protected String name = "小明";
        
            public void print(){
                System.out.println("Person");
            }
        
        }
    
        public class Student extends Person{
            private String name = "小红";
        
            public void print(){
                System.out.println("Student");
            }
            public void test1(){
                print();//Student
                this.print();//Student
                super.print();//Person
            }
        }
    
    #### 方法的重写 ####
 *  重写：子类的方法必须与父类方法必须一致，方法体不同。
 *  重写是方法的重写，与属性无关
 *  重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）
    
        public class B {
            public static void test(){ //静态方法
                System.out.println("B==>test()");
            }
        }
    
        public class A extends B{ //继承
            public static void test(){
                System.out.println("A==>test()");
            }
        }
    
        public class Application {
            public static void main(String[] args) {
                //方法的调用之和左边定义的类型有关
                A a = new A();
                a.test(); //打印 A==>test()
        
                //父类的引用指向了子类，但静态方法没有被重写
                B b = new A();
                b.test(); //打印 B==>test()
            }
        }
    
    修改A.java,B.java
    
        public class B {
            public void test(){ //非静态方法
                System.out.println("B==>test()");
            }
        }
        public class A extends B{
            @Override //重写了B的方法
            public void test() {
                System.out.println("A==>test()");
            }
        }
    
        //父类的引用指向了子类
        B b = new A(); //子类重写了父类的方法，执行子类的方法
        b.test(); //打印变成了 A==>test()
        /* 
        静态方法是类的方法，非静态方法是对象的方法
        有static时，b调用了B类的方法，因为b是b类定义的
        没有static时，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法
        */
 *  静态方法属于类，非静态方法属于对象
 *  注意点：

1.  方法名、参数列表必须相同
2.  修饰符范围可以扩大，不能缩小（public>protect>private）
3.  抛出的异常 范围可以被缩小，不能扩大
4.  被\*\*static(属于类，不属于实例)，final(常量方法)，private(私有)\*\*修饰的方法不能重写

### 多态 ###

...............

#### 接口（interface） ####

*  普通类：只有具体实现
 *  抽象类：具体实现和规范(抽象方法)都有
 *  接口：**只有规范，没有方法实现**，专业的约束！约束与实现分离：面向接口编程~
 *  接口就是规范，定义的是一组规则，"你是什么…必须做什么…"的思想。
 *  **接口的本质是约束**，就像人间法律一样，制定好大家都遵守。
    
        //interface接口,接口都要有继承类
        //实现类（implements 可以继承多个接口）
        //多继承，利用接口实现多继承
        public interface UserService {
            //定义的属性都是常量,默认修饰 public static final
            public static final int AGE = 99; //一般不用
            //所有的定义的方法都是抽象的 默认public abstract
            public abstract void run();
            void add();
            void query();
            void delete();
        }
    
    **注意点：**

1.  接口没有构造方法，不能被实例化
2.  实现类必须要重写接口中的方法
3.  实现类（implements） 可以实现多个接口

#### 内部类 ####

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

1.  成员内部类：**可以操作外部类的私有属性及方法**
2.  静态内部类：static修饰，不能访问外部类私有属性
3.  局部内部类：外部类的方法里定义的类
4.  匿名内部类：没有名字初始化类

public class Outer{
        private int id;
        public void out(){
            System.out.println("这是外部类方法");
        }
        
        public void Inner{
            publid void in(){
                System.out.println("这是内部类方法");
            }
        }
    }

public class appliaction{
        public static void main(String[] args){
            Outer outer = new Outer();
            //利用外部类来实例化内部类
            Outer.Inner inner = outer.new Inner();
            inner.in();
        }
    }