Java面向对象学习笔记-1

电玩女神 2023-10-08 18:02 53阅读 0赞

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

> 面向过程编程：程序员考虑的是程序执行步骤和每个步骤完成的事务  
> 面向对象：抽象思维把参与编程的对象用类的方法进行设计描述，最后通过调用对象的方法完成编程

## 面向对象的核心三要素 ##

> 继承：  
> 封装：  
> 多态：

## 什么是类？（class） ##

> 类是一类对象的表述，是一种抽象的行为和属性描述

//描述一个人
    public class Person{
        
       
       String name;
       int age;
       public void say(){
        
       
       }
    
    }

## 如何使用类 ##

> 想要访问类内部的方法、访问类内部的属性  
> 1.创建对象：  
> 类名 对象名称 = new 类名();
> 
> 1.  访问方法：对象名称.方法名();
> 2.  访问属性：对象名.属性名

### 类的组成 ###

> 成员变量（属性）：  
> 位置：定义在类内部，方法外的；是会初始化默认值  
> 成员方法（行为/函数）：  
> 位置：类内部（不能在内部类中）

#### 变量分类 ####

> 1.成员变量：  
> （1）修饰符的使用：可以使用修饰符，**所有访问修饰符**和部分非访问修饰可以使用，如：final static  
> （2）默认值：会具有默认值，所以可以不用显式声明变量值。  
> （3）生命周期：当对象创建时被实例，对象被销毁而销毁  
> （4）存储位置：与对象同时存在于**堆内存**中  
> （5）定义位置：定义在类内部，方法外的  
> （6）同一个类中访问的机制：能够提供给类内部所有的方法、代码块访问  
> 2.局部变量：  
> （1）修饰符的使用：不可以使用**访问修饰符**，可以使用部分非访问修饰符，如：final  
> （2）默认值：局部变量不存在默认值，只能显式声明  
> （3）声明周期：方法调用完成或代码块执行完成就被销毁  
> （4）存储位置：存放在**栈内存**中  
> （5）定义位置：代码块内部或方法内部  
> （6）同一个类中访问的机制：只能在当前代码块中访问

#### 变量通过定义位置和修饰符分类 ####

> 1.成员变量：  
> （1）实例变量：没有被static修饰的  
> （2）类变量：被static修饰的：  
> 用法：可以直接用类名.变量名访问，不需要创建对象  
> 2.局部变量：  
> （1）形参： 定义在方法参数中的变量  
> 特殊点：不能显式声明值，只能通过方法调用处实参来赋值  
> （2）代码块局部变量  
> （3）方法内部局部变量

#### 成员方法 ####

> 定义位置：类内部（不能在内部类）  
> 修饰符：访问修饰符（4类）、非访问修饰符，如：static

### 访问修饰符（public \\ private） ###

#### 在变量上使用的规则 ####

> 注意：只能在成员变量上使用

修饰符 变量类型 变量名称 = 初始值;
      public int age = 18;

作用：  
（1）public：  
在项目中所有位置都能够通过类的对象访问该属性  
（2）private：  
只能在本类内部进行访问

#### 在方法上使用的规则 ####

> 注意：只能在成员方法上使用

修饰符 返回值类型 方法名(形参){
         }
      public void say(){
        
      
      }

作用：  
（1）public：  
在项目中所有位置都能够通过类的对象访问该属性  
（2）private：  
只能在本类内部进行访问

### 非访问修饰符（static ） ###

#### 在成员变量和成员方法上的使用规则 ####

public class A{
        
    	public static int age = 0;
    	public static void say(){
        }
    }
    
    //调用时：类名.属性名/方法名()  调用
    A.age;
    A.say();

## Java内存图 ##

### 内存的组成区域 ###

> 1.栈内存空间：变量的引用地址；局部变量  
> 2.堆内存空间：变量的地址空间，包含成员变量值存储

### 内存中的关键词 ###

> 引用地址：可以指向一个内存空间位置，访问空间位置中的数据。类的对象存储的就是引用地址值

## 对象的引用指向 ##

(1)地址一对一指向
    User u1 = new User();
    (2)多个对象引用指向同一个地址空间
    User u1 = new User();
    User u2 = u1;
    (3)引用指向变更，对象垃圾出现
    User u1 = new User();//假设地址：0x123
    u1 = null;
    或者
    u1 = new User();//0x789

## 关于对象的生命周期 ##

### 成员变量生命周期 ###

> 1.  内存空间开辟（对象实例化时）就会被创建
> 2.  根据成员变量的数据类型定义默认值（基础数据类型默认值是0、0.0、fasle、\\u0000；引用数据类型默认值都是null）
> 3.  成员变量销毁是在对象内存空间销毁后才销毁（垃圾回收有关）

### 局部变量生命周期 ###

> 1.  声明时被存放在栈内存中
> 2.  只要代码块执行完成就被销毁  
>     特殊案例：引用指向销毁（对象的引用变量从栈内存中去除）

## 匿名对象调用 ##

new 类名().方法名();
    new 类名().属性名;

使用时机：

> 不建议经常使用  
> 1.如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。  
> 2.我们经常将匿名对象作为实参传递给一个方法调用

## 访问修饰符（public (default) private） ##

**权限大小顺序**：public>protected>(default)>private

### public 公共访问修饰符 ###

> 能用的地方：类、方法、成员变量  
> 访问权限：同一个项目的**所有包结构路径下**的类都能访问

### protected 子类保护访问修饰符（待整理） ###

### (defualt) 默认访问修饰符 等于不写访问修饰符 ###

> 能用的地方：类、方法、成员变量  
> 访问权限：**同包**以及**本类内部**可以访问

### private 私有访问修饰符 ###

> 能用的地方：方法、成员变量  
> 访问权限:**本类内部**可以访问

## 构造器 ##

### 构造器的作用 ###

> 1.能够在对象创建时被调用  
> 2.在对象实例化阶段调用一些特定的方法、特定的代码段或给成员变量赋值

### 构造器写法 ###

访问修饰符 所在类的类名（参数1,参数2..）{
        
        //方法体
        注意： 构造器不能写return 返回值;语句，因为构造器无法返回任何数据；注意但是可以写return控制语句，代表返回构造器调用处
    }
    
    public class User{
        
    
       public User(){
        
       
       }
       
       public User(String name,int age){
        
       
       }
       
        public User(int age,String name){
        
       
       }
    
    }

### 类中的构造器特点 ###

#### 默认构造器 ####

> 1.当类中没有编写任何构造器时，系统自动提供了一个无参构造器，且访问修饰符和当前类的修饰符一致  
> 2.如果你已经显式定义了无参或有参构造器，系统将不再提供默认构造器

#### 定义构造器时问题-构造器重载 ####

> 何为重载？  
> 构造器名称相同，参数列表不同，就实现重载  
> 重载的构造器如何被调用？  
> 根据创建对象时，参数列表值的类型和顺序去匹配构造器

#### 定义构造器的问题-修饰符的使用 ####

> 构造器上能使用的访问修饰符：4个都可以用（public protected (default) private）  
> 构造器上不能使用的非访问修饰符：static、final、synchronized、abstract、native  
> 构造器不能写return 返回值;语句，因为构造器无法返回任何数据；注意但是可以写return控制语句，代表返回构造器调用处

## this关键字 ##

### 作用： ###

> 代表当前正在调用类的方法或成员的对象（当前对象）

### 使用位置： ###

> 只能在类内部，代码块中使用

### this使用方法 ###

#### 在类内部访问成员变量 ####

public void setNameAndAge(String name,int age){
        
            //区分成员变量 和 局部变量
            this.age = age;
            System.out.println(this.age);
        }

#### 在类内部访问类中的方法 ####

public void a(){
        
       //在类内部，a方法中访问b方法
       this.b();
    }
    
    public void b(){
        
    
    }

### this调用构造器的写法 ###

this（构造器参数列表实参值1,...）
    
    如：this()  代表的就是调用当前类的**无参构造器**
       this(12) 代表的就是调用当前类的**有参构造器（参数类型为int）**

#### 特殊点： ####

> 1.  this调用构造器的代码只能在构造器方法体的第一行（保证创建对象构造器调用是最优先的）
> 2.  在编写this构造器相互调用的时候，注意逻辑不能出现调用死循环

## 方法的参数值专递 ##

> 1.  方法中，所有的参数传递机制都是**值的拷贝**

### 基础数据类型的方法值传递 ###

int a = 10
    change(a);//a变量值的拷贝 ，传入的是一个副本
    System.out.print(a);//10 传递的是拷贝副本，原变量不会发生改变
    
    
    public void change(int param){
        
       ++param;//11
    }

### 引用数据类型 ###

class User{
        
        int age = 10;
    }
    
    User user = new User();//1. 内存空间开辟，age值默认为10，引用地址赋值给user对象
    
    change(user);//2. 传递的是引用地址值的拷贝（钥匙配了一个备用的传递）
    System.out.print(user.age);// 100  
    
    //p_user 的值是user引用地址的拷贝 ，也就能够访问同一个地址空间
    public void change(User p_user){
        
    //既然能够访问同一个地址空间，则改变的变量是同一个空间的值
       p_user.age = 100;
    }

## 重载 ##

### 构造器重载的定义 ###

> 1.和访问修饰符无关  
> 2.构造器名相同（同一个类中构造器名绝对一样）  
> 3.参数列表不同（顺序、类型、数量不同），和参数名称无关

public class User{
        
    	public User(){
        }
    	User(int a,double b){
        }
    	User(double b,int a){
        }
    }

### 构造器重载的调用 ###

> 根据调用处实参的类型、顺序、数量来匹配构造器

public class User{
        
    	public User(){
        }//无参1
    	User(int a,double b){
        }//有参2
    	User(double b,int a){
        }//有参3
    }
    
    User u1 = new User();//没有参数调用无参1
    User u2 = new User(10,10.5);//实参的类型和顺序-》有参2

### 方法的重载定义 ###

> 1.和访问修饰符无关、和返回值类型无关  
> 2.方法名名相同  
> 3.参数列表不同（顺序、类型、数量不同），和参数名称无关

public void aa(){
        }
    private int aa(double a){
        }
    void aa(int a1){
        }
    int aa(double a1,int a2){
        }

### 方法重载的调用 ###

> 根据调用处实参的类型、顺序、数量来匹配方法

public void aa(){
        }//方法1
    private int aa(double a){
        }//方法2
    void aa(int a1){
        }//方法3
    int aa(double a1,int a2){
        }//方法4
    
    aa();-->方法1
    aa(10.5,100);--->方法4

## 可变参数类型 ##

> 1.一个方法中有且只能定义一个可变类型参数
> 
> 1.  可变类型参数必须定义在参数列表最后一个
> 2.  可变参数类型方法内使用和数组相同，所以无法和参数类型为数组的方法实现重载
> 3.  可变参数类型的赋值不控制实参个数，可以通过逗号分隔一直赋值，将会作为数组的实际值保存到数组中

public void test(String[] msg){
        
    	System.out.println(“含字符串数组参数的test方法 ");
    }
    public void testOne(String book){
        
    	System.out.println(“****与可变形参方法构成重载的test1方法****");
    }	
    public void testOne(String ... books){
        
    	System.out.println("****形参长度可变的test1方法****");
    }
    public static void main(String[] args){
        
    	TestOverload to = new TestOverload();
    	//下面两次调用将执行第二个test方法
    	to.testOne();
    	to.testOne(“bb" , “tt");
    	//下面将执行第一个test方法
    	to.test(new String[]{
        “abcd"});
    }

## JavaBean 的 封装和隐藏 ##

> 类中属性和方法的定义标准：
> 
> 1.  成员变量必须要私有（private）
> 2.  提供一个无参的公共构造器
> 3.  给每个私有的成员变量提供公共的getter和setter方法

public class Person {
        
    
        private int age;
        private String name;
        private String className;
        private int sex;
    
        private boolean isOk;
    
        public boolean isOk() {
        
            return isOk;
        }
    
        public void setOk(boolean ok) {
        
            isOk = ok;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public String getClassName() {
        
            return className;
        }
    
        public void setClassName(String className) {
        
            this.className = className;
        }
    
        public int getSex() {
        
            return sex;
        }
    
        public void setSex(int sex) {
        
            this.sex = sex;
        }
    }

### javaBean作用 ###

> 1.  作为数据的打包工具
> 2.  在javaEE开发中javabean作为数据的打包、操作等工具组件使用

## package、import ##

### package 包声明 ###

> 为什么使用包结构
> 
> 1.  方便大型项目中的代码管理（根据业务、使用场景区分代码）
> 2.  方便开发过程中管理成员对代码的权限（SVN、Git）

### import 导包语句 ###

> 1.  当在本类中需要使用其他包下的类时需要先导入包再使用
> 2.  导包语句可以使用.\* 来代表导入当前节点下的所有类

import java.util.Scanner;//导入特定类
    import java.util.*;//导入util包下的所有类（包含子包中的所有类）

> 感谢各位看官，如果喜欢的话点赞给我多多支持，我会一直出Java全栈开发课程内容，蟹蟹大家~磕头