本文主要是介绍JAVA面向对象基础，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

JAVA面向对象基础

一、类与实例

对象：万物皆对象，所有的东西都是对象，对象是一个自包含的实体，用一组可识别的特性和行为来标识。

类：是具有相同属性和功能的对象的抽象集合

实例：就是一个真实的对象

实例化：创建对象的过程，使用new关键字来创建

public void Test()
{
	Cat cat = new Cat();//将Cat类实例化
}

'Cat cat = new Cat();'做了两件事

Cat cat;//声明一个Cat的对象，对象名为cat
cat = new Cat();//将此cat对象实例化

二、构造方法

构造方法又叫构造函数，就是对类进行初始化。与类同名，无返回值，不需要void，在new的时候调用。

Cat cat = new Cat()

其中，Cat()就是构造方法。

所有类都有构造方法，不定义构造方法系统会默认生产空的构造方法。定义构造方法，则默认的构造就方法会消失。

public class Cat
{
    //声明Cat类的私有字符串变量name
    private String name = "";
    //定义Cat类的构造方法，参数是输入一个字符串。
    public Cat(String name)
    {
        this.name = name;//将参数赋值给私有变量name
    }
}

三、方法重载

方法重载提供创建同名的多个方法的能力，但是这些方法需使用不同的参数类型，不只构造方法可以重载，普通方法也可以重载。

方法名相同，参数类型或个数必须要有所不同。

方法重载可在不改变原方法的基础上，新增功能。

public class Cat
{
    private String name = "";
    public Cat(String name)
    {
        this.name = name;
    }
    //将构造方法重载
    public Cat()
    {
        this.name = "无名";
    }
}

四、属性与修饰符

属性

属性：是一个方法或一对方法，在调用它的代码看来，它是一个字段，即属性适合于以字段的方式使用方法调用的场合。

字段：是存储类要满足其设计所需要的数据，字段都是与类相关的变量。

//声明一个内部字段，private，默认为3
private int shoutNum = 3;
//ShoutNum属性，注意是public
public int ShoutNum
{
    //get表示外界调用时可以得到shoutNum的值
    public int get(){
        return shoutNum;
    }
    //set表示外界可以给内部的shoutNum赋值
    public void set(int value){
        shoutNum = value;
    }
}

属性有两个方法，get和set。

get：访问器返回与声明的属性相同的数据类型，调用时可以得到内部的字段的值或引用。

set：调用属性时可以给内部的字段或引用赋值。

修饰符

public：表示它所修饰的类成员可以允许其它任何类来访问，俗称公有的。

private：表示只允许同一个类中的成员访问，其它类包括它的子类无法访问，俗称私有的。

通常字段都是private，即私有变量（一般是首字母小写或前加‘_’），而属性都是public，即公有变量（首字母大写）。

final

1. 修饰变量：修饰变量时必须赋初值且不呢改变，修饰引用变量不能再指向其他对象。
2. 修饰方法：方法前面加上final关键字，代表这个方法不可被子类重写。
3. 修饰类：表示这个类不能被继承，类中的成员可以根据需要设为final，final类中的所有成员方法都会被隐饰地指定为final方法。

注：类的private方法会被隐饰地指定为final

protected：继承的子类可以对基类（父类）有完全访问权。对子类公开，不对其它类公开。

五、封装

每个对象都包含它能进行操作所需的所有信息，因此对象不必依赖其它对象来完成自己的操作，能够避免对象属性赋值的随意性。

封装的好处：

1. 良好的封装能减少耦合（相互作用相互影响的关系）。
2. 类内部的实现可以自由地修改。
3. 具有清晰的对外接口。（对外的属性和方法）set和get方法。

this关键字是对当前内的简化。

提供专门对外的set和get方法对属性进行设置，而不能用类.属性的方法修改值。

public class Student{
    private int age;//age属性私有化
    
    public Student(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = age;
    }
}

六、继承

java只支持单继承，不允许多继承。

子类继承父类：

1. 子类拥有父类所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类无法访问，只是拥有。
2. 子类拥有自己的属性和方法，即子类可以在父类的基础上做扩展。
3. 子类可以用自己的方式重写父类的方法。

package Test;

class Students {
    int age;//id属性私有化
    String name;//name属性私有化
    Students(int age,String name){
    	this.age = age;
    	this.name = name;
    }
    public void printInfo() {
		System.out.println("父类方法 年龄："+age+" 姓名："+name);
	}
}

class Student extends Students{
	Student(int age, String name) {
		super(age, name);
	}
	//重写父类同名方法
    @Override
	public void printInfo() {
		System.out.println("子类方法 年龄："+age+" 姓名："+name);
	}
	//使用super调用父类的方法
	public void FatherprintInfo() {
		super.printInfo();
	}
}
public class test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student s2 = new Student(19,"张三");
		s2.printInfo();
		s2.FatherprintInfo();
	}
}

//子类方法 年龄：19 姓名：张三
//父类方法 年龄：19 姓名：张三

super关键字

1. super用于在子类调用父类的重名方法（不重名也能引用）。
2. super在子类中引用重名的变量（不重名也能引用）。
3. super()可以用于直接调用父类的构造方法。

继承的优点

继承使得所有子类公共的的部分都放在了父类，使得代码得到了共享，就可以避免重复，继承使得修改和扩展继承而来的实现都较为容易。

继承的缺点

继承也是有缺点的，那就是父类做出修改，子类就不得不进行改变。另外，继承也会破坏包装，父类实现的细节暴露给子类。

总结：只有合理的应用继承才能发挥好的作用。例如猫继承动物，而动物不能继承猫。

七、多态的浅理解

多态表示不同的对象执行相同的操作，但是要通过自己的实现代码来执行。

注意点：

1. 子类以父类的身份出现。
2. 子类在工作时以自己的方式来实现。
3. 子类以父类身份出现时，子类特有的属性和方法不可以使用，只能用父类存在的方法。

多态有两种情形

编译时多态：

1. 重载（overload）多个同名的不同方法。

运行时多态：

1. 覆盖(override)，子类对父类方法进行覆盖（重写）。
2. 动态绑定--也称为虚方法调用，正真的方法在运行时才确定。
3. 在调用方法时，程序会正确地调用子类对象的方法。

多态中成员的特点

1.多态成员变量：编译运行看左边。

People p = new Student();
System.out.println(p.name)//p是People中的值，只能取到父类中的值。

2.多态成员方法：编译看左边，运行看右边。

People p1 = new Student();
System.out.println(p1.printInfo())//p1的表面上类型是People，但实际上是Student，所以调用的是重写后的方法。

instancof关键字

用于判断某个对象是否属性某种数据类型。

返回类型为布尔类型。

People p1 = new Student();
System.out.println(p1 instancof Student);
//true

多态的转型

向上转型

将子类对象赋值给父类变量，称之为向上转型。

//People[] people = {new Student(19,"张三"), new Teacher(30,"老师A")};
People people[];//声明一个人类数组
people = new People[1];//实例化最多两个人类对象
//向上转型
people[0] = new Student(19,"张三");
people[1] = new Teacher(30,"老师A");
//foreach遍历对象
for(People item : people)
{
    item.printInfo();
}
//年龄：19 姓名：张三
//年龄：30 姓名：老师A

向下转型

将父类变量转换为子类变量，称之为向下转型。向下转型格式如下：

子类类型 变量名 = (子类类型) 父类类型的变量
for(int i=0;i<people.length;i++){
    if(people[i] instanceof Student){
    	//向下转型
        Student student = (Student) people[i];
	}else if(people[i] instanceof Teacher){
        Teacher teacher = (Teacher) people[i];
    }else{
        System.out.println("程序错误。");
    }
}

八、抽象类

仔细观察，你会发现，People类其实根本不能实例化，一个学生长什么样子，可以想象。new People；即实例化一个人，一个人长什么样？

People是一个抽象的名词，没有其具体对象与之对应。

Java运行把类和方法声明为abstract,即抽象类和抽象方法。

abstract class People{//加abstract关键字，表面抽象类。
	......
     //在方法返回值前加abstract表明此方法是抽象方法，抽象方法没有方法体，直接在括号后面加上";"
	protected abstract void printInfo();
}

抽象类注意点：

1. 抽象类不能实例化。
2. 抽象方法必须被子类重写。
3. 如果类中有抽象方法，那么类就必须定义为抽象类，不论是否还包含其它的一般方法。

让抽象类拥有尽可能多的共同代码，拥有尽可能少的数据。

抽象类通常代表一个抽象的概念，它提供一个继承的出发点，当设计一个新的抽象类时，一定是用来继承的，所有在一个继承关系形成的等级结构里，树叶节点应当是具体类。而树叶节点均应当是抽象类。

九、接口（interface）

接口就是把隐式公共方法和属性组合起来，以封装特定功能的一个集合，一旦类实现了接口，类就可以职称接口所指定的所有属性和成员，声明接口的语法和抽象类完全相同，但不允许提供接口中任何成员的执行方式。所以接口不能实例化，不能有构造方法和字段；不能有修饰符（如public,private等）；不能声明虚拟的或静态的等。还有实现接口的类就必须要属性接口中的所有方法和属性。

一个类可以支持多个接口，多个类也可以支持相同的接口。接口的命名，前面要加一个大写的字母'I'，这是规范。

接口用interface声明，而不是class，接口名称前要加‘I’，接口中的方法或属性前面不能有修饰符、方法没有方法体。

//声明一个IPeople接口，此接口有一个printInfo方法
interface IPeople{
    void printInfo();
}

使用接口实现学生类

class Student implements IPeople{
    public void printInfo(){
        System.out.println("运行正确。");
    }
}

区分抽象类和接口

抽象类可以给出一些成员的实现，接口却不包含成员的实现，抽象类的抽象成员可被子类部分实现，接口的成员需要实现类完全实现，一个类只能继承一个抽象类，但可实现多个接口等。

区分：

1. 类是对对象的抽象；抽象类是对类的抽象；接口是对行为的抽象。
2. 如果行为跨越不同类的对象，可使用接口；对于一些相似的类对象，用继承抽象类。（实现接口和继承抽象类并不冲突）。
3. 从设计者角度来讲，抽象类是从子类对象中发现了公共的东西，泛化出父类，然后子类继承父类。而接口是根本不知子类的存在，方法如何实现还不确认，提前定义。

十、泛型

泛型是具有占位符（类型参数）的类、结构、接口和方法，这些占位符是类、结构、接口和方法所储存或使用的一个或多个类型的占位符。泛型集合类可以将类型参数用作它所存储的对像的类型的占位符；类型参数作为其字段和其方法的参数类型出现。

IList arrayPeople;//声明一个集合变量，可以用接口IList,也可以直接声明“ArrayList arrayPeople;”

用法就是在IList和List后面加''，这个'T'就是你需要指定的集合的数据或对象类型。

//声明一泛型集合变量，用接口IList,注意：IList表示此集合变量只能接受People类型，其它类型不接受，也可以直接声明“List ”
IList<People> arrayPeople;
//实例化List对象，需要指定List<T>的'T'是People
arrayPeople = new List<People>();

泛型的使用

泛型有三种使用的方式，分别为：泛型类、泛型接口、泛型方法。

public class People<T>{
	//T stands for "Type"
    private T t;
    public void set(T t){this.t = t;}
    public T get(return t);
}

• java泛型详解

• 10 道 Java 泛型面试题(opens new window)

十一、注解

Java注解是附加在代码中的一些元信息，用于一些工具在编译、运行时进行解析和使用，起到说明，配置的功能。注解不会也不呢影响代码的实际逻辑，仅仅起到辅助性的作用。

注解 Annotation 实现原理与自定义注解例子(opens new window)

十二、反射

什么是反射

可以获取任意一个类的所有属性和方法，还可以调用这些属性和方法。

Java反射主要提供以下功能：

• 在运行时判断任意一个对象所属的类；
• 在运行时构造任意一个类的对象；
• 在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）；
• 在运行时调用任意一个对象的方法；

重点：是运行时而不是编译时。

反射机制的优缺点

• 优点：可以让代码更加灵活，为各种框架提供开箱即用的功能提供了便利。
• 缺点：让我们在运行时有了分析操作类的能力，增加了安全问题。比如可以无视泛型参数的安全检查（泛型参数的安全检查发生在编译时）。另外，反射的性能也会稍差点。不过，对框架来说影响不大。Java Reflection: Why is it so slow?

反射的应用场景

我们平时大部分时候都是在写业务代码，很少会接触到直接使用反射机制的场景。

但是，这并不代表反射没有用。相反，正是因为反射，你才能这么轻松地使用各种框架。像 Spring/Spring Boot、MyBatis 等等框架中都大量使用了反射机制。

这些框架中也大量使用了动态代理，而动态代理的实现也依赖反射。

• Trail: The Reflection API(opens new window)
• 深入解析 Java 反射（1）- 基础(opens new window)

十三、异常

在Java中，所有的异常都有一个共同的祖先java.lang包中的Throwable类，Throwable类有两个重要的子类Error(错误)和Exception(异常)。其中Error用来表示JVM(Java虚拟机)无法处理的错误，Exception又分为两种：

• 受检查异常：需要用try-catch语句捕获并进行处理，并且可以从异常中恢复。
• 不受检查异常：java代码在编译过程中，即使不处理不受检查异常也可以正常通过编译。是运行时的错误，例如除0会引发ArithmeticException(算术错误异常)，此时程序崩溃并且无法恢复。RuntimeException及其子类都统称为非受检查异常。

• 图片来自：https://simplesnippets.tech/exception-handling-in-java-part-1/

• 图片来自：https://chercher.tech/java-programming/exceptions-java

Throwable类常用方法

public string getMessage()//返回异常发生时的简要描述。
public string toString()//返回异常发生时的详细信息。
public string getLocalizedMessage()//返回异常对象的本地化信息。使用Throwable的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与getMessage（）返回结果相同。
public void printStackTrace()//在控制台上打印Throwable对象封装的异常信息。

try-catch-finally

try块：用于捕获异常，后面可以接零个或多个catch块，如果没有catch块，则必须跟一个finally块。

catch块：用于处理try捕获到的异常。

finally块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。

在下面三种特殊情况下，finally块不会被执行：

• 在try或finally块中用了System.exit(int)退出程序。如果System.exit(int)在异常语句之后，finally还是会被执行。
• 程序所在的线程死亡
• 关闭CPU

注意：当try语句和finally语句中都有return语句时，在方法返回之前，finally语句的内容将被执行，并且finally与的返回值会覆盖原始的返回值，如下：

public class Test{
	public static int f(int value){
		try{
            return value*value;
        }finally{
            if(value == 2)
                return 0;
        }
	}
}

如果调用f(2)，返回值将是0，因为try语句的返回值被finally语句的返回值覆盖。

使用try-with-resources来代替try-catch-finally

1. 适用范围（资源的定义）：任何实现java.lang.AutoCloseable或者java.io.Closeable的对象。
2. 关闭资源和finally块的执行顺序：在try-with-resources语句中，任何catch或finally块在声明的资源关闭后运行。

《Effecitve Java》中明确指出：

面对必须要关闭的资源，我们总是应该优先使用try-with-resources而不是try-finally。随之产生的代码更简短，更清晰，产生的异常对我们也更有用。try-with-resources语句让我们更简短清晰，产生的异常对我们更有用。try-with-resources语句让我们更容易编写必须要关闭的资源的代码，若采用try-finally则几乎做不到这点。

Java中类似于InputStream、OutputStream、Scanner、PrintWriter等的资源都需要我们调用close()方法来手动的关闭。

使用try-catch-finally语句实现：

//读取文本文件的内容
Scanner scanner = null;
try{
	scanner = new Scanner(new File("D://read.txt"));
    while(scanner.hasNext())
    	System.out.println(scanner.nextLine());
}catch (FileNotFoundException e){
    e.printStackTrace();
}finally{
    if(scanner != null)
        scanner.close();
}

使用Java 7之后的try-with-resources语句改造上面的代码：

try (Scanner scanner = new Scanner(new File("D:\\read.txt"))){
	while(scanner.hasNext())
    	System.out.println(scanner.nextLine());
}catch (FileNotFoundException e){
    e.printStackTrace();
}

通过使用分号分隔符，可以在try-with-resources块中声明多个资源。

try(BufferredInputStream bin = new BufferredInputStream(new FileInputStream(new File("test.txt"))); BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))){
	int b;
    while((b = bin.read()) != -1)
        bout.write(b);
}catch (IOException e)
{
    e.printStackTrace();
}

• Java提高篇-Java异常处理

十四、I/O流

• I/O流详解

这篇关于JAVA面向对象基础的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！