java面向对象

最新推荐文章于 2022-06-20 12:14:42 发布

qq_42186263

最新推荐文章于 2022-06-20 12:14:42 发布

阅读量310

点赞数

分类专栏： java 文章标签： java 面向对象编程大数据人工智能

抚琴

本文链接：https://blog.youkuaiyun.com/qq_42186263/article/details/112570397

版权

本文详细介绍了Java的面向对象特性，包括封装、类、构造方法、局部变量、对象的创建与销毁、this关键字、static关键字及其应用，如静态变量、静态方法和静态代码块，以及类的继承、重写父类方法、super关键字的使用、构造器调用。此外，还讨论了抽象类、接口的声明与实现，以及多态的概念和使用。通过对这些概念的深入探讨，读者可以更好地理解和掌握Java的面向对象编程思想。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

java面向对象

1、封装

定义
封装就是把对象的属性（状态）和方法（行为）结合在一起，并尽可能隐蔽对象的内部细节，成为一个不可分割的独立单位（即对象），对外形成一个边界，只保留有限的对外接口使之与外部发生联系。

原则
使对象以外的部分不能随意存取对象的内部数据，从而有效的避免了外部错误对它的“交叉感染”。

数据隐藏特性提升了系统安全性，使软件错误能够局部化，减少查错和排错的难度。

2、类

定义
类就是对象的模板，而对象就是类的一个实例。

类由属性和方法构成：

对象的特征在类中表示为成员变量，称为类的属性。
类的方法是对象执行操作的一种规范。方法指定以何种方式操作对象的数据，是操作的实际实现。

[访问符] [修饰符] class <类名>{
   
         [属性]
         [方法]
}
//声明一个类，定义一个长方形（Rectangle）类，有长、宽属性，对每个属性都提供相应的get/set方法 
public class Rectangle {
   
	/* 长方形宽度 */
	private double width;
	/* 长方形高度 */
	private double length;
	/* 成员变量对应的方法 */
	public double getWidth() {
   
		return width;
	}
	public void setWidth(double width) {
   
		this.width = width;
	}
	public double getLength() {
   
		return length;
	}
	public void setLength(double length) {
   
		this.length = length;
	}
}

成员变量

public class a {
   
   String wing;
   String claw;
   String beak;
   String feather;
}

成员方法

 //权限修饰符 private public protected
   //void 不需要返回值
   public void show(){
   
       System.out.println("看我");
   }
   //返回一个 int值
   public int show1(){
   
       System.out.println("nishi");
       return 1;
   }

成员方法参数

一格式：

权限修饰符返回值类型方法名（形参列表）{
方法体;
}
定义成员方法的语法格式如下：

权限修饰符返回值类型方法名(参数类型参数名){
…//方法体
return 返回值;

二说明：
一个成员方法可以有参数，这个参数可以是对象，也可以是基本数据类型的变量，同时成员方法有返回值和不返回值的选择，如果方法需要返回值，可以在方法体中使用 return 关键字，使用这个关键字后，方法的执行将被终止。

public class add {
   
    public static void main(String[] args) {
   
        add book = new add();
        int x = 1000;
        int y = 100;
        System.out.println("运算结果"+ book.addd(x,y));
        System.out.println("实际x参数" + x);
    }
    private int addd(int x,int y){
   
        x = x+y;
        return x;
    }
}

运行结果：

运算结果1100
实际x参数1000

引用参数

public class Ref {
   
    public static void main(String[] args) {
   
        int[] i = {
   0,1,2};
        System.out.println("原来的数组是：");
        for (int j = 0;j < i.length;j++){
   
            System.out.println(i[j]);
        }
        System.out.println("被改变后的数组是：");
        Ref ref = new Ref();
        ref.chang(i);
    }
    public  void chang(int [] i){
   
        i[0] = 1000;
        i[1] = 2000;
        i[2] = 3000;
        for (int j = 0;j < i.length; j++){
   
            System.out.println(i[j]);
        }
    }
}

结果是：

原来的数组是：
0
1
2
被改变后的数组是：
1000
2000
3000

不定长参数

public class Ref {
   
    public static void main(String[] args) {
   
        Ref ref =new Ref();
        ref.chang(1,2,2,2,2,2,210000);
    }
    public  void chang(int...x){
   
        int a = 100;
        for (int j = 0;j < x.length; j++){
   
           a +=100;
            System.out.println(a);
        }
    }

结果：

public class Ref {
   
    public static void main(String[] args) {
   
        Ref ref =new Ref();
        ref.chang(1,2,2,2,2,2,210000);
    }
    public  void chang(int...x){
   
        int a = 100;
        for (int j = 0;j < x.length; j++){
   
           x[j] +=100;
            System.out.println(x[j]);
        }
    }
}

结果：

仔细看结果一次是调用数组长度，一次是值总之引用了 int…

java构造方法

1.方法名与类名相同
2.没有返回类型（void也不行）
3.构造方法是在创建实例时会被自动调用
4.一个类可能没有构造方法，但一定有系统隐蔽无参的构造方法，也有多个构造方法（他们之间构成重载）
5.定义了有参数的构造方法，就会屏蔽掉系统无参构造方法
6.构造方法不能被继承

public class Ref {
   
    public static void main(String[] args) {
   
        Ref b = Ref.ref();
    }

    public Ref() {
   


    }
    static public Ref ref (){
   
        System.out.println("我是构造方法");
        return new Ref();
    }
}

运行结果：

我是构造方法

局部变量

在成员方法内定义一个变量，那么这个变量被成为局部变量。

public class Ref {
   
    public void aa(){
   
        int aaa = 100;
    }
}

对象创建访问对象的属性和行为

public class Ref {
   
    public void aa(){
   
        int aaa = 100;
        System.out.println(aaa);
    }

    public static void main(String[] args) {
   
        Ref ref =new Ref();
        ref.aa();
    }
}

结果：

销毁对象

每一个对象都有两个属性:

Reachable可达，Finalizer-Reachable终接器-可达，Unreachable不可达
Unfinalized未终结，Finalizable可终结，Finlized已终结

对象可达：对象被任意一个存活线程引用。对程序进行优化设计的一种方法是减少原本可达状态的对象。例如，当编译器或代码生成工具不论明确或隐性声明一个变量或者参数时，变量或参数不再使用NULL去存储一个可能被回收的对象。

终接器-可达：对象可以被处于终结状态的链接或者存在引用，但并不会被任何存活的线程访问到。

不可达：对象不能通过任何方法访问。

未终结：对象未被Finalizer(终接器）自动访问finalize方法

已终结：对象已被Finalizer(终接器）自动访问finalize方法

可终结：对象未被Finalizer(终接器）自动访问，但JVM已经访问finalize方法

对象生命周期转化图
对象生命周期转化图

A：对象创建
B C D E F : 一个可达的对象的引用程序执行过程中废弃
G H : 如果JVM发现一个未终结对象变为终接器-可达或者不可达
I ：JVM发现一个已终结对象状态变为不可达，这时可能发生内存回收导致对象彻底回收
J K : JVM会一直执行某个线程，将任何可回收对象的 finalize方法调用。对象转变为已终结可达状态
L M N : JVM会一直执行某个线程，将任何可回收对象的 finalize方法调用，此时发生对象自救对象转变为可达状态
O ：如果一个类的对象未覆盖finalize方法，对象突然消失而不是等待之后把对象转变为不可达状态，那么对象的实例会转变为不可达状态。

对象不可能处于不可达可终结，由于对象可以被终接器调用终结方法，因此对象必然是可达的，这样终接器线程才能够调用对象的终结方法。因此一个对象只能处于上述八种状态。

一个对象被终结后，在内存自动回收管理器将对象转变为不可达状态前不能再进行对对象进行操作。

当一个未终结对象从可终结状态转变为已终结状态，JVM不会自动调用多次任何对象的finalize方法，即使这个对象再一次变为可达在其变为已终结状态之后。

终接器明确的调用不受当前对象状态的影响，且不会改变对象的终结属性。

程序狗们得注意啦，终接器在启动期间可以自动调用方法，即使对象状态为可达，更进一步来说，终接器也可以自动调用对象的普通方法。因此建议设计对象的finalize方法尽量简单和安全，这样可以使程序的健壮性更好。

this关键字

public class Ref {
   


    public static void main(String[] args) {
   
            //调用无参构造函数，
            Person p1 = new Person();
            p1.setAge(20);
            p1.setName("张三");
            p1.setGender("男");
            System.out.println(""+p1.getName()+" 今年"+p1.getAge()+"岁 性别为："+p1.getGender());
        }

    }
    class Person{
   
        private String name;
        private int age;
        private String gender;
        Person(){
   }
        Person(String name,int age,String gender){
   
            this.name = name;
            this.age = age;
            this.gender = gender;
        }
        public void setName(String name){
   
            name = name;
        }
        public String getName(){