JavaSE_面向对象

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

面向对象&面向过程

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么…
- 面对过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，需要我们使用面向对象的思路老分析整个系统。但是，具体到微观操作，任然需要面向过程的思路去处理。

什么是面向对象？

面向对象编程(Object-Oriented Programming，OOP)
面向对象编程的本质就是：以类的方式组织代码，一对象的组织(封装)数据。
抽象
三大特性
- 封装
- 继承
- 多态
从认识论角度考虑是先有对象后有累。对象是累的具体事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法

什么是方法

Java方法是语句的集合，他们在一起执行一个功能
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

方法可以被理解为是：一个人要从A点到达B点：从A点到达B点这个事需要解决吧，但是怎么解决呢，这个人可以用走路，坐公交，打的···等等多种方式，这些方式都是方法，解决某件事的办法，就是方法。

Java中方法就是用来完成解决某一件事的办法。

我们可以通过在程序代码中引用方法名称和所需的参数，实现在改程序中调用该方法。

方法，一般都会有一个返回值，用来作为事情的处理结果。

设计方法的原则：方法的本意是功能模块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样有利于我们后期的拓展。

方法的定义及调用

方法的命名规范：

首字母小写加驼峰原则。(驼峰原则，除了第一个单词外，后面单词首字母都大写，如：goodBoy)。

方法的定义及调用

方法的定义

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
方法包含一份方法头和一个方法体。（以下是一个方法的所有部分）
修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。returnValueType是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType是关键字void。
方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型，顺序和参数的个数。参数是可选的，方法可以不含任何参数。
形式参数：在方法被调用时用于接收外界的数据。
实参：调用方法是传给方法的数据。

方法体：方法体包含具体等语句，定义该方法的功能。

语法结构

修饰符 返回值类型 方法名(参数类型 参数名){
   ···
   方法体
   ···
   return 返回值;
}

方法的调用

调用方法：对象名.方法名(实参列表)
Java支持两种调用方法的方式，根据方法是否有返回值来选择。
当方法返回一个值的时候，方法调用通常会被当做一个值，例如：
int larger = max(30,40);
如果方法返回值是void，方法调用一定是一条语句。

public class Test{
    public static void main(String [] args){
        int sum=add(3,4);   //调用add方法
        System.out.println(sum);//7
    }
    //我们的方法一般是放在main方法外面的
    public static int add(int a,int b){ //加static使这个方法成为类变量，这样就可以直接在这个类中直接调用了
        return a+b;  //返回（a+b）这个值给调用者
    }
}

public class Test {
	public static void main(String[] args) {
		Test test=new Test();  //调用方法
		test.test();
	}
	    public void test(){   //void 是“空”的意思
	        System.out.println(1);
	        System.out.println(1);
	        System.out.println(1);
	    }
}

类与对象的创建

类与对象的关系

类是一种很抽象的数据类型，他是对某一类事物整体描述/定义，三十并不能代表某一个具体的事物。
- 动物、植物、手机、电脑…
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特征和行为。
对象是抽象概念的具体实例
- 张三就是人的一个具体事例，张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

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

具体理解对象

初学肯定对于对象这个概念很模糊对吧

所以，这里是我在我的笔记上另外加的我对于对象的理解

先来简单回忆一下上述：

对象是抽象概念的具体实例
- 张三就是人的一个具体事例，张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

构造器详解

回顾:

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

无参构造

//定义一个类
public class Demo01{
    //无参构造
    public Demo01(){
        System.out.println("Hello!");
    }
}

在这里插入图片描述

public class Application{
    public static void main(String[] args){
        Demo01 d1 = new Demo01();//当对象被创建时，构造器就会执行
    }
}

有参构造

//定义一个类
public class Demo02{
    //有参构造
    public Demo01(int i;String str){//可以理解为就是给构造器一个参数
        System.out.println("Hello!");
    }
}

public class Application{
    public static void main(String[] args){
        Demo01 d1 = new Demo01(1,"Hello");//当创建对象的时候，调用有参构造必须传进参数，不然会报错
    }
}

如果定义了有参构造，无参构造必须显示定义
在这里插入图片描述

不然_你懂得~
在这里插入图片描述

封装

该露的露，该藏的藏
我们程序设计要追求"高内聚，低耦合"。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量方法给外部使用。

封装(数据的隐藏)
通常，应禁止直接访问一个对象数据的实际表示，而应通过操作接口来访问，这称为信息影藏。

记住这句话就够了:属性私有，get/set

public class Demo{
    private String name;//private私有(外部不可访问)
    private int age;
    //提供可以操作这些属性的方法
    //提供一些public的get，set方法
    //get 方法获取这个数据(name)
    public String getName(){
        return this.name;
    }
    //set方法给这个数据设置值(name)
    public String getName(String name){
        this.name = name;
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界的更好的建模。
extends的意思是"扩展"。子类是父类的扩展。
Java中类只有单继承，没有多继承！(可以简单理解为一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子)
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
子类和父类之间，从意义上讲应该具有"is a"的关系。

子类的定义

//结构：
public class 子类名 extends 父类名{
    
}

在这里插入图片描述

子类继承父类，就会拥有父类的一切方法(public方法)

定义一个父类:

public class Father{//这里我是便于区分，所以类名取了Father
    public void say(){
        System.out.println("Oh!my son,you should remenber“good goog study,day day up”!!!");//这里纯属搞笑哈
    }
}

再定义一个子类继承Father类

public class Son extends Father{
    //子类中什么都不写
}

这时我们调用子类

public class Application{
    public static void main(String[] args){
        Son son = new Son();
        son.say();//这里真的可以调用哦，不信的话看图↓
    }
}

私有方法无法继承

object类

所有类都直接或者间接继承object类
如果你用的是IDEA，那么你可以定义一个类然后按CTRL+H右边会出现一个继承树

super

super注意

super调用父类的构造方法，必须在构造方法的第一个
super必须只能出现在子类的方法或者构造方法中！
super和this不能同时调用构造方法！

this与super的不同点

代表对象的不同
this：本省调用者这个对象
super：代表父类对象的应用

前提：
this：没有继承也可以使用
super：只能在继承条件下才可以使用

构造方法：
this()：本类的构造
super()：父类的构造

方法重写

为什么需要重写？

父类的功能子类不一定需要或者不一定满足！

public class A{//父类
    public static void test(){
        System.out.println("A's test");
    }
}

public class B extends A{//子类
    public static void test(){
        System.out.println("B's test");
    }
}

public class Application{//启动
    public static void main(String[] args){
        //方法的调用只和左边的类型有关
        B b = new B();
        b.test();//输出为B's test
        //父类的引用指向了子类
        A a = new B();
        a.test();//输出为A's test
    }
}

注意：静态方法和非静态方法区别很大！

我们将static去掉：

public class A{//父类
    public  void test(){
        System.out.println("A's test");
    }
}

public class B extends A{//子类
    public  void test(){
        System.out.println("B's test");
    }
}

public class Application{//启动
    public static void main(String[] args){
        //方法的调用只和左边的类型有关
        B b = new B();
        b.test();//输出为B's test
        //父类的引用指向了子类
        A a = new B();
        a.test();//输出为B's test
        //子类重写了父类的方法——只针对非静态
    }
}

重写

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小(public > protected > default > private)
抛出的异常：范围可以被缩小但不能扩大(ClassNotFoundException < Exception)(例)
子类的方法和父类必须一直，方法体不同。

多态

参考“菜鸟教程”

同一个事件发生在不同的对象上会产生不同的结果

多态的优点

消除类型之间的耦合关系
可替换性
可扩展性
接口性
灵活性
简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Father f =new Son();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理

//以下是一个多态实例的演示，详细说明请看注释：

Test.java 文件代码：
public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}
//来自菜鸟教程

instanceof和类型转换

instanceof

作用

判断两个类之间是否存在父子关系

A类（父类）

public class A{
}

B类（子类）

public class B extends A{
}

启动类

public class Application{
    public static void main(String[] args){
        Object b1 = new B();

        System.out.println(b1 instanceof B);
        System.out.println(b1 instanceof A);
        System.out.println(b1 instanceof Object);
        System.out.println(b1 instanceof String);
    }
}

运行结果：

true
true
true
false

类型转换

高转低——强制类型转换

低转高——无需强制转换

public class Application{
    public static void main(String[] args){
        A a = new B();
        a.run();//会报错
        ((B)a).run();//将a-A类型强制转换为a-B
        //此时a可以用B类所独有的方法
        //可以直接说“父类引用指向子类对象，需要用到子类特有的方法时，需要用到强制类型转换”
    }
}
class A{
    public void eat(){
        System.out.println("eat!");
    }
}
class B extends B{
    public void run(){
        System.out.println("run!");
    }
}

子类转换为父类时，可能会丢失一些方法！！！

总结

父类引用指向子类对象

把子类转换为父类——向上转型

把父类转换为子类——向下转型

方便方法的调用，减少重复的代码

抽象类

adstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

public abstract class A{
    //这是一个抽象类
}

抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

public abstract class A{
    public void run(){
        //没有错误
    }
}

public  class A{
    public abstract void run();//有错误
}

抽象类，不能使用new关键字来创建对象，他是用来让子类继承的。（抽象类不能被实例化）

public class Application{
    public static void main(String[] args){
        A a = new A();//有错误
    }
}
abstract class A{
    
}

抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

接口

声明类的关键字是class，声明接口的关键字是interface

普通类：只有具体实现
抽象类：具体实现和规范(抽象方法)
接口：只有规范！
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。
如果你是天使，则必须能飞。
如果你是汽车，则必须能跑。
如果你是好人，则必须干掉坏人。
如果你是坏人，则必须欺负好人。

接口的本质就是契约，就像我们人间的法律一样，制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们要讨论设计模式都只针对具备了抽象能力的语言(如：C++、java、C#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象

定义一个接口：

public interface A{
    //这是一个接口
}

接口的操作

public interface A{
    void run();
    //可以直接定义为返回值类型+方法名()
    //默认都是public abstract修饰的
    int AGE = 99;
    //接口中的属性都是常量
    //默认都是public static final修饰的(全局静态常量)
}

public interface B{
    void eat(String foodName);
    //可以定义参数类型
}

public class Aimpl implenments A,B{
    //命名规范:接口名+impl=接口的实现类
    //接口可以实现伪多继承
    //实现接口必须重写接口中的方法！！！
    @Override
    public void run(){
    }
    @Override
    public void eat(String foodName)
}

接口任然不能被实例化~

接口中没有构造方法~

内部类

内部类就是在一个类的内部再定义一个类，比如：在A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类来说就是外部类了。
内部类
成员内部类
静态内部类
局部内部类
匿名内部类

成员内部类

//外部类
public class Outer{
    private int age = 16;
    public void out(){
        System.out.println("这是外部类的out方法！");
    }
    //内部类
    public class Inner{
        public void in(){
        System.out.println("这是内部类的in方法！");
        }
        public void getAge(){
            System.out.println(age);
            //内部类可以操作外部类的私有属性、私有方法！！！
        }
    }
}

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

静态内部类

用static修饰的内部类

//外部类
public class Outer{
    private int age = 16;
    public void out(){
        System.out.println("这是外部类的out方法！");
    }
    //内部类
    public static class Inner{
        public void in(){
        System.out.println("这是内部类的in方法！");
        }
        public void getAge(){
            System.out.println(age);
            //当内部类为静态内部类，外部类非静态类时，无法访问外部类的属性以及方法！！！
        }
    }
}

局部内部类

在方法里面的内部类

//外部类
public class Outer{
    private int age = 16;
    public void out(){
        System.out.println("这是外部类的out方法！");
        class Inner{
        public void in(){
        System.out.println("这是内部类的in方法！");
        }
        
    }
}

匿名内部类

没有名字初始化类——不用将实例保存到变量中！！！

public class Application{
    public static void main(String[] args){
        new Phone();
        //这个~没有名字~~
        //but
        new Phone().call();
        //依旧可以使用它的方法
    }
}
class Phone{
    public void call(){
    }
}

如有错误和不足，欢迎指出！！！

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

JavaSE_面向对象

面向对象&面向过程

什么是面向对象？

方法

什么是方法

方法的定义及调用

方法的定义及调用

方法的定义

语法结构

方法的调用

类与对象的创建

类与对象的关系

创建与初始化对象

具体理解对象

构造器详解

封装

继承

子类的定义

object类

super

方法重写

多态

instanceof和类型转换

instanceof

类型转换

总结

抽象类

接口

内部类

成员内部类

静态内部类

局部内部类

匿名内部类

如有错误和不足，欢迎指出！！！

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯