Java类和对象知识点的整理

朱雀 2022-04-24 03:14 259阅读 0赞

通过学习视频，特意写下此次博客。本次博客目的是为了理解面向对象的思想，掌握面向对象的基本原则以及 Java 面向对象编程基本实现原理，熟练使用封装、继承、多态面向对象三大特性。仅是博主本人总结，可能会有很多不足之处，希望读者可以有目的的阅读。

## 一、类和对象 ##

**1.面向对象**  
（1）面向对象的理解

*  面向对象是已对象为基础，完成各种操作主要强调对象。

（2）面向对象的特点

*  面向对象是一种常见的思想，比较符合人们的思考习惯；
 *  面向对象可以将复杂的业务逻辑简单化，增强代码复用性；
 *  面向对象具有抽象、封装、继承、多态等特性。

**2.类和对象**  
（1）类：即模子，确定对象将会拥有的特征（属性）和行为（方法）。  
（2）类的特点：类是对象的类型，是具有相同属性和方法的一组对象的集合。  
（3）属性：对象具有的各种特征（每个对象的属性都拥有特定值）。  
（4）方法：对象执行的操作。  
（5）类和对象的关系：类是抽象的概念，仅仅是模板；对象是一个你能够看得到、摸得着的具体实体。

**3.定义类**

（1）定义类的步骤

*  a.定义类名
 *  b.编写类的属性
 *  c.编写类的方法

public class 类名{
    			//定义属性部分（成员变量）
    			属性1的类型 属性1；
    			属性2的类型 属性2；
    			...
    			属性n的类型 属性n；
    			//定义方法部分
    			方法1；
    			方法2；
    			...
    			方法m；
    }

**4.成员变量和局部变量区别**  
（1）作用域不同

*  局部变量的作用域仅限于定义它的方法
 *  成员变量的作用域在整个类内部都是可见的

（2）初始值不同

*  Java会给成员变量一个初始值，Java不会给局部变量赋予初始值。

（3）在同一个方法中,不允许有同名局部变量;在不同的方法中,可以有同名局部变量

（4）两类变量同名时,局部变量具有更高的优先级

**5.构造方法：**  
（1）使用new+构造方法创建-个新的对象  
（2）构造方法是定义在Java类中的一个用来初始化对象的方法，构造方法与类同名且没有返回值。  
（3）无参构造方法的使用

main():
    Telphone phone = new Telphone0;
    class Telphone:
    	public Telphone() {
    		System.out.println("Telphone构造方法执行了");
    	}

（4）带参构造方法的使用

main():
    Telphone phone2 = new Telphone(4.0f, 2.0f, 2.0f);
    class Telphone:
    	public Telphone(float newScreen,float newCpu,float newMem) {
    		screen = newScreen;
    		cpu = newCpu;
    		mem = newMem;
    }

（5）当没有指定构造方法时,系统会自动添加无参的构造方法。  
（6）当有指定构造方法,无论是有参、无参的构造方法，都不会自动添加无参的构造方法。  
（7）构造方法的重载:方法名相同,但参数不同的多个方法，调用时会自动根据不同的参数选择相应的方法。  
（8）构造方法不但可以给对象的属性赋值,还可以保证给对象的属性赋一一个合理的值。

构造方法的语句格式
    没有返回值类型，与类名相同
    public构造方法名(可以指定参数){
    //初始化代码
    }

**6.static**  
（1）静态变量

*  static修饰的成员被称为静态成员或类成员，它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享，静态成员可以使用类名直接访问，也可以使用对象名进行访问，更推荐类名访问；

语法：类名.静态变量名 或 对象.静态变量名

*  使用static可以修饰变量、方法和代码块；
 *  静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间，直到该类被缺载时才会进行资源回收。

（2）静态方法

*  静态方法可以直接调用同类中的静态成员，但不能直接调用非静态成员。如果想调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量；

语法：类名 对象名=new 类名();System.out.println(对象名.非静态变量名);

*  在普通成员方法中，则可以直接访问同类的非静态变量和静态变量；
 *  静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

（3）静态初始化块

*  在类的声明中，可以包含多个初始化块（用\{\}包含），当创建类的实例时，就会依次执行这些代码块。如果使用static修饰代码块，就称为静态初始化块；
 *  静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的变量成员；

语法：static{};

*  程序运行时，静态初始化块最先被执行，然后执行普通的初始化块，最后才执行构造方法。

## 二、 封装 ##

**1.封装**  
（1）概念:  
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问  
（2）好处:

*  a.只能通过规定的方法访问数据
 *  b.隐藏类的实例细节,方便修改和实现

（3）封装的实现步骤  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FzMTc4MDkyNTk3MTU_size_16_color_FFFFFF_t_70]  
**2.使用包管理Java中的类**

1.Java中的包  
（1）包的作用:

*  管理Java文件
 *  解决同名文件冲突

（2）定义包: package包名  
注:必须放在Java源程序的第一行，包名间可以使用"."号隔开eg:com.imooc.MyClass。  
例如:音乐类一-MyClassMusic

-music
      com.imooc.music.MyClassMusic
      
    -movie
      com.imooc.movie.MyClassMusic

**3.系统中的包**

*  java.（功能）.（类）
 *  java.lang.（类）包含java语言基础的类
 *  java.util.（类）包含java语言中的各种工具类
 *  [java.io][].（类）包含输入、输出相关功能的类

**4.包的使用**  
( 1 )可以通过import关键字,在某个文件使用其它文件中的类.  
import com.imooc.music.MyClass  
( 2 ) Java中,包的命名规范是全小写字母拼写  
( 3 )使用的时候不但可以加载某个包下的所有文件  
eg: com.imooc.\*  
也可以加载某个具体子包下的所有文件eg:com.imooc.music.\*

**5.Java中访问控制符**  
（1）四种访问控制符的权限大小(由大到小)为public(公共)、protected(保护)、default(默认)、 private(私有)。

*  private(私有)：当类中属性或方法被private修饰时，表示此成员或方法只能被自己类中的方法使用，而不能被外部类或对象直接使用。
 *  default(默认)：具有包访问权限，如果类中属性或方法不使用public,protected,privete修饰符修饰时，则说明其具有包访问权限，具有包访问权限的属性或方法既可以被自己类中的方法使用也可以被同一包下的其他类使用，但不能被其他包中的类使用。
 *  protected(保护)：具有子类访问权限。如果类中属性或方法被protected修饰符修饰，则此类中属性或方法可以被同一包下的类使用，也可以被不同包下的子类使用，但不能被不同包下的其他类使用。例如：
 *  public(公共)：具有公共访问权限。如果类中的属性或方法被public修饰，则此类中的属性或方法可以被任何类调用。

**6.Java中this关键字**  
（1）this关键字的主要三个应用

*  this调用本类中的属性，也就是类中的成员变量；
 *  this调用本类中的其他方法；
 *  this调用本类中的其他构造方法，调用时要放在构造方法的首行。

注意：系统自动生成set和get方法；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FzMTc4MDkyNTk3MTU_size_16_color_FFFFFF_t_70 1]  
**7.Java中的内部类**  
（1）概念：

*  内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

（2）作用：

*  内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
 *  内部类的方法可以直接访问外部类的所有数据，包括私有的数据
 *  内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

（3）好处

*  实现多重继承。
 *  内部类可以很好的实现隐藏：一般的非内部类，是不允许有 private 与protected权限的，但内部类可以。
 *  减少了类文件编译后的产生的字节码文件的大小。  
    （4）缺点
 *  使程序结构不清楚。

**8.成员内部类**  
（1）概念

*  成员内部类也叫实例内部类。应用场合：每一个外部类对象都需要一个内部类的实例，内部类离不开外部类存在（相当于心脏对人体）。

（2）成员内部类的特征：

*  作为外部类的一个成员存在，与外部类的属性、方法并列
 *  成员内部类持有外部类的引用
 *  成员内部类中不能定义static变量和方法

（3）使用格式

//外部类0uter
    public class Outer {
    private int a = 99; //外部类的私有属性//内部类Inner
    public class Inner {
    int b = 2;//内部类的成员属性public void test() {
    System. out . println("访问外部类中的a:”+ a);System. out . println("访问内部类中的b:”+ b);
    
    }
    }
    //测试成员内部类
    public static void main(String[] args) {
    Outer。= new outer();//创建外部类对象，对象名为o
    Inner i = o.new Inner();// 使用外部类对象创建内部类对象，对象名为ii.test();//调用内部类对象的test方法
    
    }

注意：外部类是不能直接使用内部类的成员和方法滴

//外部类HelloWorld
        public class HelloWorld {
          public class Inner {
          //内部类的方法
          public void show() {
          System. out . printIn("welcome to imooc !");
    }
    }
       public void print() {
          show(); 		//外部类调用内部类的成员方法，外部类不能直接访问内部类中的成员方法
    	}
    }

注意：可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。  
（4） 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：

//外部类Outer
    public class Outer {
    int b = 1;//外部类中的成员属性b
    //内部类Inner
    public class Inner {
    int b = 2; 	//内部类的成员属性b
    public void test() {
    System. out . println("访问外部类中的b：" + Outer. this.b);
    System. out . println("访问内部类中的b: " + b);
    
    }
    }

（5）创建内部类的对象  
需要先创建外部类的对象，然后外部类对象名.new 内部类();

//创建外部类的对象
    Helloworld 0 = new Helloworld ();//创建内部类的对象
    Inner inn = o. new Inner()

**9.静态内部类**  
（1）内部类如果使用static声明，则此内部类就称为静态内部类。（其实也相当于外部类）可以通过外部类 . 内部类来访问。

（2）静态内部类使用场合：内部类不需要外部类的实例（注意区分成员内部类），静态内部类存在仅仅为外部类提供服务或者逻辑上属于外部类，且逻辑上可以单独存在。

（3）静态内部类的特征：

*  静态内部类不会持有外部类的引用
 *  静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

（4）Java中只有内部类才可以是静态的  
**10.局部内部类**  
（1）局部内部类也叫区域内嵌类，局部内部类与成员内部类类似，不过，区域内嵌类是定义在一个方法中的内嵌类。  
（2）使用场合：如果内部类对象仅仅为外部类的某个方法使用，使用局部内部类  
（3）特征：

*  用在方法内部，作用范围仅限于该方法中
 *  根据情况决定持有外部类对象引用
 *  不能使用private，protected，public修饰符
 *  不能包含静态成员

**11.匿名内部类**  
（1）如果一个内部类在整个操作中只使用一次的话，就可以定义为匿名内部类。匿名内部类也就是没有名字的内部类，这是java为了方便我们编写程序而设计的一个机制，因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适。  
（2）使用场合：简化内部类的使用  
（3）特征：

*  使用new创建 ，没有具体位置
 *  创建的匿名类，默认继承或实现new后面的类型
 *  根据使用情况决定是否持有外部类对象引用
 *  内嵌匿名类编译后生成的.class文件的命名方式是”外部类名称$编号.class”，编号为1，2，3…n，编号为x的文件对应的就是第x个匿名类

## 三、继承 ##

**1.重写**  
（1）什么是方法的重写:

*  如果子类对继承父类的方法不满意,是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。

（2）语法规则:

*  a.返回值类型
 *  b.方法名
 *  c.参数类型及个数

注意：都要与父类继承的方法相同,才叫方法的重写。

**2.继承的初始化顺序**  
（1）初始化父类再初始子类  
（2）先执行初始化对象中属性,再执行构造方法中的初始化  
注意：Java中是单继承的。  
**3.final关键字**

（1）使用final关键字做标识有”最终的”含义。

（2）final可以修饰类、方法、属性和变量

*  final修饰类,则该类不允许被继承
 *  final修饰方法,则该方法不允许被覆盖(重写)
 *  fina|修饰属性

注意：则该类的属性不会进行隐式的初始化(类的初始化属性必须有值)或在构造方法中赋值(但只能选其一)

（3）final修饰变量,则该变量的值只能赋一次值,即变为常量  
**4.super关键字:**  
在对象的内部使用,可以代表父类对象。  
（1）访问父类的属性

super.age

（2）访问父类的方法

super.eat()

注意：通过super()关键字调用父类无参的构造方法，但是必须放到第一行。  
（3）子类的构造的过程当中必须调用其父类的构造方法。

*  如果子类的构造方法中没有显示调用父类的构造方法,则系统系默认调用父类无参的构造方法。
 *  如果显示的调用构造方法,必须在子类的构造方法的第一行。
 *  如果子类构造方法中既没有显式调用父类的构造方法,而父类又没有无参的构造方法,则编译出错。

**5.Object类**  
默认的是所有类的父类，其类中的方法如下：  
（1） toString ( )方法

*  在Object类里面定义toString ( )方法的时候返回的对象的哈希code码(对象地址字符串)
 *  可以通过重写toString ( ) 方法表示出对象的属性

注意：重写toString方法，不用自己写，直接source中选  
（2）equals( )方法

*  比较的是对象的引用是否指向同一块内存地址。Dog dog = new Dog()
 *  一般情况下比较两个对象时比较他的值是否一 致,所以要进行重写。

## 四、多态 ##

**1.概念：**

*  允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。

**2.创建父类对象，也可以引用父类创建子类对象**

Animal obj1 = new Animal);
    Animal obj2 = new Dog0;//父类的引用是可以指向子类对象的

**3.多态的分类：**  
（1）引用多态

*  父类的引用可以指向本类的对象父类的引用可以指向子类的对象

（2）方法多态

*  创建本类对象时,调用的方法为本类方法
 *  创建子类对象时,调用的方法为子类重写的方法或者继承的方法

**4.引用类型转换**  
（1）向上类型转换(隐式/自动类型转换) ,是小类型到  
大类型的转换  
（2）向下类型转换(强制类型转换) ,是大类型到小类型3. instanceof运算符,来解决引用对象的类型,避免类型转换的安全性问题

Dog dog = new Dog0;
    
          Animal animal = dog://向上类型转换自动类型转换
          if(animal instanceof Dog){
         	 	 Dog dog2 = (Dog)animal;
         	 }else{
         		 System.outprintIn("无法进行类型转换);
          }
          if(animal instanceof Cat){
    			Cat cat = (Cat)animal://1.编译时Cat类型2.运行时Dog类型
    	  }else{
      			System.outprintIn(无法进行类型转换");
         }

**5.抽象类**  
（1）概念：

*  抽象类前使用abstract关键字修饰,则该类为抽象类。

（2）应用场景:

*  在某些情况下,某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
 *  从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类 作为子类的模板,从而避免了子类设计的随意性。

（3）作用:  
限制规定子类必须实现某些方法,但不关注实现细节  
（4）使用规则

*  abstract定义抽象类
 *  abstract定义抽象方法,只有声明,不需要实现
 *  包含抽象方法的类是抽象类
 *  抽象类中可以包含普通的方法,也可以没有抽象方法e.抽象类不能直接创建,可以定义引用变量

**6.接口**  
（1）接口概念

*  接口可以理解为一种特殊的类,由全局常量和公共的抽象方法所组成。

（2）接口定义

*  和类定义不同,定义接口不再使用class关键字,而是使用interface关键字。

接口定义的基本语法:
    [修饰符]jinterface 接口名[extends父接口1,父接口...]
    {
    零个到多个常量定义...
    零个到多个抽象方法的定义...
    }

注意：接口就是用来被继承、被实现的,修饰符一般建议用public注意:不能使用private和protected修饰接口

（3）接口定义

*  常量:

接口中的属性是常量,即使定义时不添加public static final修饰符,系统也会自动加上。

*  方法:

接口中的方法只能是抽象方法,总是使用,即使定义时不添加public abstract修饰符,系统也会自动加上。  
（4）使用接口

*  一个类可以实现一个或多个接口,实现接口使用implements关键字。Java中一个类只能继承一个父类,是不够灵活的通过实现多个接口可以做补充。
 *  继承父类实现接口的语法为:

[修饰符] class类名extends父类implements接口1 ,接口2...
    {
    类体部分//如果继承了抽象类,需要实现继承的抽象方法;要实现接口中的抽象方法。
    }

注意：如果要继承父类,继承父类必须在实现接口之前

（5）使用接口:

*  接口在使用过程当中，还经常与匿名内部类配合使用 匿名内部类就是没有名字的内部类,多用于关注实现而不关注实现类的名称。

语法格式:
    Interface i= new Interface(){
    	public void method() {
    		System.out.println("匿名内部类实现接口的方式");
    		}
    };

**为了更好的理解类和对象，做了答答租车系统的项目练习，具体的代码，以及实现过程，附上博客地址：**

[https://blog.csdn.net/qs17809259715/article/details/89297448][https_blog.csdn.net_qs17809259715_article_details_89297448]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FzMTc4MDkyNTk3MTU_size_16_color_FFFFFF_t_70]: /images/20220220/9ee72bbbf5a4470aad611701173cf102.png
[java.io]: http://java.io
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FzMTc4MDkyNTk3MTU_size_16_color_FFFFFF_t_70 1]: /images/20220220/793ae0ad53e84caab7ee8cd1be88f5e7.png
[https_blog.csdn.net_qs17809259715_article_details_89297448]: https://blog.csdn.net/qs17809259715/article/details/89297448