本文共 6982 字，大约阅读时间需要 23 分钟。

面向对象入门

面向对象的优点：

1.符合人们思考习惯

2.将复杂的事情简单化

3.将程序员从执行者转换成指挥者

语法：

[public/private/protected/default] class 类名{
   	成员属性；    成员方法；}

对象的实例化：

new 类名();

匿名对象：

1.用作方法参数

2.用作匿名内部类

类中的成员访问：

1.使用static修饰的属性，方法称为静态属性，静态方法

2.没有被static修饰的属性，方法称为非静态属性，非静态方法，又被称为实例属性，实例方法

空间分配：

1.静态的成员（属性，方法）是属于类的，在类第一次加载到内存中的时候，就已经分配空间了

2.非静态的成员是属于对象的，在实例化对象的时候分配空间

访问：

1.静态成员需要使用类访问，非静态成员需要使用对象访问

2.静态方法中可以直接访问本类中的静态成员，不能直接访问本类中的非静态成员

3.非静态方法中可以直接访问本类中的静态成员，也可以直接访问本类中的非静态成员

static：

1.被static修饰的成员会变成静态，具有保值功能

2.在方法区的内部有一块特殊的区域–静态方法区，专门用来盛放被static修饰的成员，可以延长成员的存活时间与字节码一致

3.字节码文件对象（Dog.class,Student.class),是在程序执行时，由JVM负责将字节码文件生成字节码文件对象，内部包含类的所有二进制形式的内容。每个类都有唯一的一个字节码文件对象，负责当前类所有实例对象的创建工作（new方法执行具体的开辟空间，构造方法执行具体的属性初始化），字节码文件对象的生存周期与类一致，是整个程序

4.正是因为JVM创建了字节码文件对象，类名调用静态成员时本质上是由字节码文件对象调用，同理，字节码文件对象创建时，实例对象还不一定被创建，显然类名无法直接调用实例成员

static的作用：

1.用于保值

2.用于工具类的创建

类是一种自定义的数据类型

this关键字：

1.this是一种引用数据类型，本身是一个关键字，用在类的实例方法或者构造方法中，代表的是当前的对象，保存的是当前对象的地址

2.当局部变量和成员变量重名时，this.属性是成员变量，没有this的是局部变量

3.可以在构造方法内部调用其他的重载的构造方法，提高代码的复用性，简化代码

class Student{
       String name;    String sex;    int age;    double score;        //无参构造方法    public Student(){
   }    //一参构造方法    public Student(String name){
           this.name = name;    }    //两参构造方法    public Student(String name,String sex){
           this.name = name;        this.sex = sex;    }    //三参构造方法    public Student(String name,String sex,int age){
           this.name = name;        this.sex = sex;        this.age = age;    }    //四参构造方法    public Student(String name,String sex,int age,double score){
           this.name = name;        this.sex = sex;        this.age = age;        this.score = score;    }        //使用this优化    //无参构造方法    public Student(){
   }    //一参构造方法    public Student(String name){
           this.name = name;    }    //两参构造方法    public Student(String name,String sex){
           this(name);        this.sex = sex;    }    //三参构造方法    public Student(String name,String sex,int age){
           this(name,sex);        this.age = age;    }    //四参构造方法    public Student(String name,String sex,int age,double score){
           this(name,sex,age);        this.score = score;    }    }

构造方法：

1.构造方法本质上也是一个方法，用于实例化对象，在实例化对象时调用

2.构造方法的名字必须和类名一致

3.构造方法没有返回值，返回值类型不用写

4.一般情况下，使用构造方法是为了在实例化对象的同时传参，给一些属性进行初始化赋值

5.如果类中没有写构造方法，那么系统会自动提供一个无参构造方法，但如果一个类中写了构造方法，那么系统不再默认提供无参构造方法，所以当我们要重写构造方法时，最好先写一个无参构造方法，再写其他的构造方法,多个构造方法直接是重载关系

this在构造方法中的使用：

1.不能自己掉自己—死循环

class Student{
       public Student(){
           this();        System.out.println("调用构造方法");    }}

2.不能相互调用—死循环

class Student{
       String name;    public Student(){
           this("张三");    }    public Student(String name){
           this();    }}

3.this充当构造方法时，必须放在第一行

4.this在作为方法的时候，只能充当构造方法，不能作为其他方法

5.this的作用范围仅限于当前类的内部

6.只有非静态方法才可以使用this

代码段:

构造代码块：构造代码段中的代码在每次实例化对象的时候执行，执行顺序优先于构造方法，对对象的某些属性进行初始化的赋值，但在实际应用中，以构造方法的使用较多

class Student{
       {
           //构造代码段    }}

静态代码段：被static修饰的代码段，当类第一次加载到内存中的时候执行，一般进行属性的初始化赋值，或者进行资源加载，执行顺序优先于main

public class demo4 {
       static{
           System.out.println("我是主类中的静态代码段");        System.out.println("静态代码先于main方法执行");    }    public static void main(String[] args) throws ClassNotFoundException {
           //类加载时机        //1.调用Class.forName("全限定名");        Class.forName("bk.java.p519.Person");        //2.实例化对象        Person person = new Person();        //3.访问静态成员        System.out.println(Person.name);    }}class Person{
       static{
           System.out.println("我是静态代码段");    }    static{
           System.out.println("一个类中可以写多个静态代码段");        System.out.println("多个静态代码段之间的执行顺序取决于书写顺序");    }    {
           System.out.println("我是构造代码段");    }    static String name = "张三";}执行结果：我是主类中的静态代码段静态代码先于main方法执行我是静态代码段一个类中可以写多个静态代码段多个静态代码段之间的执行顺序取决于书写顺序张三

完整的类名：

包名.类名

封装（private）：

定义：我们可以通过对具体属性的封装实现，把对成员变量的访问进行私有化，让他只能在类内部可见，通过公共的方法间接实现访问

优点：提高了代码的安全性，复用性和可读性

脏数据：

我们把程序中出现的不符合逻辑的数据称为脏数据

getter和setter方法：

public void setAge(int age){
   	this.age = age;}

public int getAge(){
   	return this.age;}

继承（extends）：

特点：

1.程序中的继承，是类与类之间的特征和行为的一种赠予与获取。一个类可以将自己的属性和方法赠与其他的类，一个类也可以从其它类中获取他们的属性和方法

2.两个类之间的继承，必须满足is a的关系

3.产生继承关系后，子类可以使用父类中的属性与方法，也可以定义子类独有的属性与方法

4.在Java中，类是单继承，一个类有且只能有一个直接的父类，可以有若干个间接的父类，一个父类可以有0个或者多个子类，子类之间互不影响

5.使用继承，可以简化代码，提高代码的复用性，提高代码的扩展性，增加代码的健壮性，最重要的是类与类之间产生了继承的关系，是多态的前提

继承的语法：

子类 extends 父类Object类：作为java继承体系中所有类的父类，Object类没有父类

不可以被继承：

1.构造方法：

构造方法是为了创建当前类的对象的，不可以继承给子类

2.私有成员：

私有成员只能在当前的类中使用，不可以继承给子类

父类的私有成员在子类中可见不可用

3.跨包子类：

默认权限的属性，方法，不可以继承给跨包的子类、

（属性，方法）访问修饰符：

	当前类	同包其他类	不同包子类	不同包其他类
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

(类)访问修饰符：

类的访问修饰符只能是public或者default，

public:当前工程的全类可见

default：当前包可见

方法重写：

子类可以继承到父类中的属性和方法，但是有些方法，子类的实现和父类的实现可能不同，当父类提供的方法已经不能满足子类的需求时，子类可以定义与父类相同的方法，这时子类方法完成对父类方法的覆盖，称为重写

判断一个方法是不是重写的方法，使用注解@Override

重写的注意事项：

重写方法名字必须和父类方法名字相同，参数列表一致，访问权限必须大于等于父类的访问权限，返回值需要小于等于父类方法的返回值类型

super:

this是一种引用类型，代表当前对象，保存的是当前对象的地址。而super代表当前对象的父类，可以调用父类的成员，但它不是引用数据类型

继承中使用构造方法：

1.子类对象在实例化的时候，需要先实例化从父类继承到的部分，此时通过super()默认调用父类中的无参构造方法

2.super()方法是默认的，不需要显式地写出来

final：

1.最终的，最后的，被final修饰的内容是不能被改变的

2.final修饰的类不能有子类

3.final修饰的变量是一个常量，不能再被改变，所以在定义时必须要先手动赋值

4.final修饰的方法不允许被重写

空白final：

//空白final在final的使用上提供了更大的灵活性，因为一个类中的final域可以做到根据对象而有所不同，却又保持其恒定不变的特性class Student{
       final String birthday;    public Student(String birthday){
           this.birthday = birthday;    }}

Object：

在java中，Object类是所有类的顶级父类，它最重要的是就是里面的11个方法

getClass()获取对象的字节码文件对象，每个类都有唯一的字节码文件对象

toString()展示属性的值

hashCode()Object类的hashCode方法默认返回的是对象哈希码值十六进制形式，在同一个project中，我们可以认为是唯一的，大部分情况会重写它，通过重写改变对象哈希值的计算方法

/*equals:equals默认比较的是对象的地址，无实际意义*/@Overridepublic boolean equals(Object o){
       //若两对象地址相同，内容必然相同    if(this == o) return true;    //如果传进来的对象地址为空，那内容必然不相同    if(o == null) return false;    //判断两对象的真实类型是否相同，如果不相同，则一定不相等    if(this.getClass() != o.getClass()) return false;    //比较内容之前，由于属性是子类独有的属性，所以必须进行拆箱    Student s = (Student)o;    //比较内容    if(this.name.equals(s.name) && this.sex.equals(s.sex) && this.age==s.age && this.score==s.score)        return true;}

组合：

当我们把一个类作为另一个类的属性，让它们之间产生关系时，他们的关系是组合—>谁拥有谁

多态

父类引用指向子类的对象

java的运行分为两个阶段：

编译阶段：从打开程序到执行运行之前–>只能识别前面的引用类型，不会识别后面的对象

运行阶段：从运行开始–>识别的是后面的对象，对象干活

动态加载：

我们在编译阶段不能确定具体的对象类型，只有到了运行阶段才能确定正在的干活对象

多态的优点：

可以提高代码的扩展性，使用之前定义好的功能，后面直接拿来用，不用创建新的方法

转型：

前提是多态，在多态的前提下才有向上转型和向下转型的概念

向上转型：

对象由子类类型，转为父类类型，即是向上转型（父类引用指向子类对象，从而访问父类定义的属性与方法，实现多态）

向下转型：

对象由父类类型，转为子类类型，即是向下转型（子类引用指向父类对象，从而访问子类独有的属性与方法）

instanceof：

1.向下转型，存在着失败的可能性，如果引用实际指向的对象，不是要转型的类型，此时强制转换，会出现ClassCastException异常

2.在向下转型时，需要使用instanceof来判断当前对象是否是后面的类或者子类的对象，是返回true，不是返回false

多态中的方法重写：

当向上转型后的对象，调用父类中的方法，如果这个方法已经被子类重写了，此时调用的就是子类的重写实现！

父子类出现了同名成员：

继承下的调用规则：

1.成员变量：调用子类的

2.成员方法：调用子类的，子类没有再去调用父类的

多态下的调用规则：

成员变量：编译的时候能不能访问看父类，运行的时候也看父类

成员方法：编译的时候能不能访问看父类，运行时看子类

静态成员方法：编译运行都看父类

抽象类：

在继承中，提取父类方法的时候，每个子类都有自己具体的方法实现，父类不能决定他们各自的实现方法，所以父类干脆就不管了，在父类中只写方法的声明，将方法的实现交给子类。拥有抽象方法的类叫做抽象类

特点：

1.除了可以拥有抽象方法，普通类的属性与方法，抽象类都可以拥有

2.抽象类不可以创建对象

3.拥有抽象方法的类一定是抽象类

功能：

可以约束子类（非抽象）必须实现父类定义的抽象方法，方便规则的制定

抽象方法：

只有方法声明，没有实现

abstract class Animal{
       String name;    public abstract void eat();}

转载地址：https://blog.csdn.net/m0_56433040/article/details/117380841 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！