Java面向对象程序设计

最新推荐文章于 2024-04-14 16:49:02 发布
最新推荐文章于 2024-04-14 16:49:02 发布
阅读量392 收藏 3
点赞数 3
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39663586/article/details/109708511
版权

继承（extends）

继承是面向对象程序设计中另一个重要的特征，继承即由一个类从另一个通过extends关键字继承，被继承的类称之为父类(也叫超类)，继承的类称之为子类（扩展类）；继承可以使得类的扩展性提高，减少重复代码的编写。

[<修饰符>] class 子类 extends 父类 { 
}

实例:

父类Father：

public class Father {

	public String name;
	public int age;
	
	public void coding() {
		System.out.println(name + "超级会写代码");
	}
	
	public void love(){
		System.out.println("情场高手!!!!");
	}
	
}

子类Son:

public class Son extends Father{

	//通过代码表现：动物 猫 老鼠之间的关系
	public static void main(String[] args) {
		Son s = new Son();
		s.name = "刘德华";
		s.coding();
		s.love();
	}
}

继承优点

  1. 子类可以直接通过对象调用父类中的非私有元素
  2. 子类还可以在父类的基础上扩展新的功能

继承注意事项

  • 子类只能继承父类的属性和方法，不能继承构造器
  • 子类对象构造之前会先执行父类的构造器（如果存在多重继承，则从最顶层父类构造器开始执行）
  • 一个父类可以存在多个子类，但是一个子类只能存在一个父类
  • Java不允许多继承，但是支持多重继承
  • 被protected修饰的元素可以在子类中被访问（即便父类和子类不在同一个包）

重写(override)与重载(overload)

Java中允许方法的重写和重载，重写和重载是多态的一种实现策略：

  • 重载（overload）：一个类中存在多个同名的方法
  • 重写（override）：一个子类对父类的方法覆盖

重写

​ 当父类中的方法实现满足不了子类需求时，此时子类中可以编写一个与父类方法一模一样的方法，对父类的方法进行覆盖，该过程称之为方法的重写（Override）.

案例：

Animal类

public class Animal {

	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
    //动物咆哮（不同的动物发出的叫声一样，因此无法一概而论）
	public void bark() {
		System.out.println(name + "哇哇哇哇啊啊...");
	}
	
}

Dog类

public class Dog extends Animal{
	//对bark方法重写
	public void bark() {
		System.out.println(getName() + "汪汪汪。。。");
	}
}

Cat类

public class Cat extends Animal{
	//对bark方法重写
	public void bark() {
		System.out.println(getName() + "喵喵喵。。。");
	}
}

重载

​ 重载指的是在同一个类中，或者存在继承关系的多个类中，存在同名的方法，这些方法的名称一模一样，但是方法的参数个数 ，类型，顺序任意有一项不一致，具备以上特点的方法统一称之为重载方法。

重载的条件:

  1. 方法名称必须一致
  2. 参数的个数、顺序和类型任意有一项不一致
  3. 重载与返回值无关
public class Driver {

	public void driven(Car c) {
		
	}
	
	public void driven(Bus b) {
		
	}
	
	public void driven(Bike b) {
		
	}
	
	public void driven(Plane p) {
		
	}
}

关于方法的重载和重写的区别？

  1. 重写必须存在继承关系，由子类重写父类的方法，重载无要求
  2. 重写的方法名称，参数类型必须和父类一致；重载必须要保证方法的参数列表任意有一项不一致
  3. 重载与返回值无关

装箱拆箱

在JDK1.5之后，引入了装箱和拆箱机制，用于实现基本类型数据和对应的封装类型之间的自动转换。

  • 装箱(boxing)：将基本类型的数据值包装为对应的引用类型对象
  • 拆箱(unboxing)：将封装类型中的基本数据值拆成为基本数据类型
//装箱（boxing）
Integer i = 10;

//拆箱(unboxing)
int j = new Integer(10);

设计模式之-单例模式（Singleton）

​ 设计模式即在软件开发历史中,经过不断迭代和演变形成的一套针对于某些特定问题，所提供的的专门的解决方案;在java中常见的设计模式包含23种，比如：

  • 单例模式
  • 模板方法
  • 简单工厂
  • 适配器模式
  • 观察者模式
  • 代理模式
  • 装饰模式
  • …

单例模式概述

单例模式也称之为单态模式，单子模式等；指的是在程序运行的过程中始终只存在一个对象(实例)。单例模式的表现形式又分为两种：

  1. 懒汉式（需要的时候才创建：以时间换空间的概念）
  2. 饿汉式（类加载即创建：以空间换时间的概念）

应用场景

​ 单例模式的使用场景十分广泛，比如：数据库连接池，字符串常量池，线程池等资源池，比如日历类，Runtime类等常见与系统环境交互相关的类。

懒汉式

懒汉式即需要实例对象时才创建：

/**
 * 	单例模式 - 懒汉式（需要时才创建）
 * @author mrchai
 */
public class Singleton {

    //实例变量（成员变量，全局变量）
    //类变量
	private static Singleton instance; //15db9742
	
	//构造器私有化，不允许外界随意访问（不允许随便创建对象）
	private Singleton() {}
	
	public static Singleton newInstance() {
		if(instance == null) {
			instance = new Singleton();
		}
		return instance;
	}
	
}

饿汉式

饿汉式即类加载时就创建实例对象

/**
 * 	单例模式-饿汉式(类加载即创建对象) 
 * @author mrchai
 *
 */
public class Singleton2 {

	private static Singleton2 instance = new Singleton2();
	
	private Singleton2() {
	
	public static Singleton2 newInstance() {
		return instance;
	}
}

抽象类（abstract class）

java中凡是普通类都具备实例化对象的能力，因为一个类具备了实例化对象的一些必要信息，比如属性，比如行为；但是有些时候，当一个类中信息不足以描述一个具体对象时，此时该类就应该考虑定义为抽象类。

java中的抽象类中所包含的信息，不足以描述一个具体对象，抽象类的内部成分由以下信息构成:

  • 属性
  • 构造器
  • 行为
    • 已实现
    • 未实现（抽象方法）

抽象类基本案例

特点
  1. 抽象类必须使用abstract修饰
  2. 抽象类存在构造器，但是无法实例化（可以使用匿名内部类创建子类对象）
  3. 抽象类中通常会包含抽象方法
  4. 抽象类的存在一般是需要由子类继承，子类一旦继承了抽象类，则子类必须实现父类中的抽象方法（除非子类也是抽象类）
  5. 抽象类允许继承其他抽象类，但是也只能单继承，可以通过多重继承的方式实现多继承
  6. abstract只能修饰类和方法
案例:
/**
 * 	抽象类
 * @author mrchai
 */
public abstract class Animal {

	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//抽象方法
	public abstract void eat();
	public abstract void sleep();
	
}
    
}

Dog类:

public class Dog extends Animal{

    //实现方法
	public void eat() {
		System.out.println("吃骨头");
	}
	//实现方法
	public void sleep() {
		System.out.println("睡狗屋");
	}

}

接口（interface）

接口是一种比抽象类更纯粹的抽象；因为内部只能够存在常量以及未实现的方法（JDK8以前），接口通常用于定义一些未实现方法的集合，但是不对法方法具体实现，具体的实现通常是由实现类完成，接口具备以下特征：

  • 接口不存在构造器，因此无法实例化
  • 接口允许继承接口，可以同时继承多个接口
  • 一个类可以实现多个接口，但是必须要同时实现所有接口的方法（除非抽象类）
  • 抽象类也实现接口
  • JDK8中对接口有其他新增特性（默认方法，静态方法，函数式接口）

语法

/**
 * 	接口即标准
 *  USB接口：只是一种标准的定义，不包含具体实现
 *  	一流的公司定义标准  做架构
 * 		二流的公司卖服务      写框架	
 * 		三流的公司卖产品     写CRUD	
 * 
 * 	定义一个接口
 * @author mrchai
 */
public interface Flyable {
	
	//默认编译器会将以下代码完善成: public static final String msg = "hello";
	String msg = "hello";
	
	//编译器会将以下代码自动完善：public abstract void fly()
	void fly();
	
}

抽象类和接口区别

  • 抽象类是一种类结构，接口是一种行为准则
  • 抽象类中包含类的所有特征，同时包含抽象方法；接口只能有常量和未实现的方法
  • 抽象类由子类通过extends进行扩展；接口由实现类通过implements扩展
  • 子类只能继承一个抽象类；一个类可以实现多个接口
  • 抽象类能且只能继承一个父类；接口可以继承多个接口，接口不能继承任何类
  • 抽象类是对类(名词)的一种抽象；接口是对行为(动词，形容词)的抽象，接口是一种特殊的抽象类

多态详解（polymorphism）

多态的体现包含两种层面：

  1. 方法层面（重写和重载）
  2. 属性层面
    1. 父类引用指向子类对象
    2. 子类引用指向父类对象（原本就是子类）

多态也称之为动态绑定：在运行期间动态为引用变量绑定具体的对象数据

内部类

通常一个java文件中只能包含一个public class，但是可以在一个java类的内部中嵌套其他的java类，这种类称之为内部类，也叫嵌套类，或者类属类，比如：

public class People {

    public void m(){
        
    }
    
	public static void main(String[] args) {
		
	}

	//内部类
	class Body{
		
	}
}

//不是内部类，和People是平级的关系
//class Head{  
//}

以上就是一个典型的内部类,生成的字节码文件如下:

People$Body.class
People.class

java中的内部类包含以下几种定义方式：

  1. 成员内部类
  2. 局部内部类
  3. 静态内部类
  4. 匿名内部类

内部类的好处

  • 提供了比方法更好的封装性
  • 提高类多继承的可能性

成员内部类

成员内部类即在类结构中直接定义的与属性，方法，构造器同一级别的类。

public class People extends JFrame{

	public void m1() {
		System.out.println("外部类方法");
//		new Body().m3();
	}

	//内部类
	private class Body extends ArrayList{
		
		String name;
		
		public void m2() {
			System.out.println("内部类方法");
		}
		
		public void m3() {
			
		}
	}

}

成员内部类的使用场景：在JDK中有很多类使用到了成员内部类，例如: ArrayList
成员内部类注意事项:
成员内部类类似成员方法，允许被任意的访问修饰符修饰（default,public,private,protected）

局部内部类

所谓局部内部类即在一个类的方法或者其他成员的(构造器，游离块)语句块中定义，不太常见：

public class User {

    int n;
    
	public void login() {
		//jdk1.8之后无需显式定义final（编译器自动添加）
		final int i = 10;
		class Validate{
			public void t() {
                //成员变量在局部内部类中允许修改
                n = 100;
                //变量i在局部内部类只能使用不能修改
				System.out.println("======="+i);
			}
		}
		Validate v = new Validate();
		v.t();	
	}
	
	public void reg() {
		//编译错误：找不到类
//		Validate v = new Validate();
//		v.t();	
	}
	
	public static void main(String[] args) {
		User u = new User();
		u.login();
	}
}

** 局部内部类注意事项:**

  1. 不能使用任何的访问修饰符(除了default外)修饰，原理参考局部变量的定义
  2. 局部内部类中不能对方法中的局部变量进行修改，如果局部内部类中需要使用为外部方法的局部变量时，该变量必须定义为final（java8无需显式定义final，编译器默认添加）
  3. 使用final修饰局部变量的作用在于延长局部变量的生命周期，避免因为方法的结束而被清理（可能局部内部类在使用该变量）

静态内部类

静态内部类即使用static修饰的成员内部类；静态内部类与外部类的对象无关，一般用于数据缓存，比如Integer中的静态内部类：IntegerCache

/**
     * Cache to support the object identity semantics of autoboxing for values between
     * -128 and 127 (inclusive) as required by JLS.
     *
     * The cache is initialized on first usage.  The size of the cache
     * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
     * During VM initialization, java.lang.Integer.IntegerCache.high property
     * may be set and saved in the private system properties in the
     * sun.misc.VM class.
     */

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

自定义静态内部类:

public class StaticClass {

	public void m() {
		System.out.println("外部类方法");
	}
	
	public static class MyCache{
		
		static String msg = "天干物燥，小心火烛";
		
		public static void t() {
			System.out.println("静态内部类的方法");
		}
		
		public void m2() {
			System.out.println("静态内部类的普通方法");
		}
		
	}
}

静态内部类的对象创建与方法调用:

//创建静态内部类的对象
StaticClass.MyCache cache = new StaticClass.MyCache(); 
//调用静态内部类的静态方法
StaticClass.MyCache.t();
//调用静态内部类的成员方法
cache.m2();

匿名内部类

匿名内部类即没有名字的内部类，通常用于事件监听机制，回调机制中

public abstract class Animal {

	public abstract void eat();
	
}

实例:

public static void main(String[] args) {		
    //匿名内部类
    Animal a = new Animal(){			
        int i = 10;		
        public void eat() {
            i = 20;
            System.out.println("吃狗肉"+i);
            m();
        }
        //由于匿名内部类没有名称
        //则内部定义的方法外界无法访问
        //通常方法使用private修饰
        private void m() {
            System.out.println("----");
        }
    };
    a.eat();
}

接口的匿名内部类使用

接口的声明:

public interface Flyable {

	void fly();
	
}

接口匿名内部类使用:

Flyable f = new Flyable() {
    public void fly() {
        System.out.println("fly。。。。");
    }
};
f.fly();
PCI_DN
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JAVA面向对象程序设计
qq_64924526的博客
04-19 3063
第二章 继承 2.1 继承 相同的属性和方法从父类继承，避免了代码的重复，也方便了日后的修改。 语法： 修饰符 class SubClass extends SuperClass { //类定义部分 } 继承(inheritance)通过extends关键字了实现，其中的SubClass称为子类，SuperClass称为父类、基类或超类。修饰符如果是public，则该类在整个项目中可见；若无public修饰符，则该类只在当前包可见，不可以使用private和protected.
Java—面向对象程序设计
O2_H2O的博客
02-15 5526
文章目录一、面向对象编程1. 类类的声明类的成员数据类的成员方法二、对象属性的初始化1.引入库2.读入数据总结 一、面向对象编程 面向对象是一种程序设计方法，使用对象和类等基本概念来进行程序设计，是一种符合人类思维习惯的编程思想。 类：是对现实世界事物的抽象定义，是对某类事物的描述。（类的成员包括属性和方法） 对象：是类的实例。 OOP操作过程：创建类，定义属性和行为后添加构造方法 1. 类 类的声明 示例：<修饰符> class <类名> { [<属性声明>]
JAVA-面向对象程序设计
最新发布
2401_84025026的博客
04-14 965
1. 一个类主要有三个部分组成：1.1 构造方法：用来创建对象1.2 成员变量：也称属性，用来表示对象的状态1.3 方法：对象的行为2. 如何创建类//定义int 类型的变量int name;//定义speak（）方法} //Person 类名，name 是成员变量，speak（）成员方法3. 类修饰符：3.1 public: 这个public关键字声明了类可以在其他类中使用。其缺省时，该类只能被同一个包下的其他类使用。
Java基础篇：内部类详解
张维鹏的博客
10-06 4332
目录： 一、内部类的好处： 二、成员内部类： 三、局部内部类： 四、静态内部类： 五、匿名内部类： 六、总结： 内部类：可以将一个类的定义放在另一个类的定义内部，这就是内部类。 内部类是一个编译时概念，编译后外部类及其内部类会生成两个独立的class文件： OuterClass.class和OuterClass$InnerClass.class。 在Java中内部类主要分为四...
面试常问：说下内部类有什么好处？都有哪些类呢？
Java后端架构V
05-16 708
1、首先，把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private,protected,default,public，它有类成员的修饰符: static,final,abstract；2、非静态内部类nested inner class：隐含有一个外部类的指针this,因此，它可以访问外部类的一切资源，包括private。外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级。非静态内部类不能包含任何static成员。
【JavaSE】面向对象程序设计（一）
DFminer
05-08 286
成员变量只能定义在类中（对象里）局部变量可以定义在方法或者语句中1.没有返回值，因为对象创建之后就结束了，不需要结果，void不需要写，要区别一般方法。2.一个类可以有多个构造方法，它们都是以重载的格式出现的3.构造方法也有return语句的，用于初始化结束（加不加都行，后面都没有语句了）4.构造方法 可以用private修饰，但是没有意义构造方法是对象初始化调用的？给哪个对象初始化了？通过this关键字记录住对象的地址，并通过this来明确初始化对象在构造方法中调用其他构造方法。
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计(源代码+课后习题答案)（耿祥义 张跃平 清华大学出版社）
JAVA面向对象程序设计教案
07-12
Java 面向对象程序设计教案 本教案旨在帮助学生掌握 Java 面向对象程序设计的基本知识和技能，包括 Java 语言的基本概念、Java 虚拟机、Java 程序的开发和运行环境的配置等。通过本教案的学习，学生将具备编写 Java...
Java程序设计——面向对象
weixin_51614108的博客
04-26 317
面向对象编程（java） 前言：面向对象（Object Oriented）是一个编程理念，其发明者曾经获得图灵奖我喜欢你。对于初学者来说，应该从最直观的角度 来理解什么是面向对象。 1.1 认识类和对象 1.1.1 类 int age; String name; String sex; 其中int是一个数据类型。但是每次定义都需要定义多个变量。那么能否像int样“自创”一个数据类型（customer）使用？ 答案是可以的。面向对象中的类（Class）就可以帮助用户完成。 1.1.2 定义类 最简单
PCI9052中文手册（绝对中文）
05-21
PCI9052中文手册（绝对中文）！！PCI9052中文手册（绝对中文）！！！
内部类有哪些好处？什么时候使用内部类
02-12 944
链接： http://www.cnblogs.com/jpa2/archive/2012/04/24/2527538.html 提起Java内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），
Java 接口的应用：PCI
m0_46527503的博客
11-10 2077
展示接口实现“功能扩展” 【需求】主板预留PCI插槽。不可能知道该插槽将插装什么硬件。 主板做的事情只能是：加电、启动、run、停止。 主板类预留5个PCI插槽，如何实现？ interface PCI{ //PCI插槽应遵循的标准 void start(); void run(); void stop(); } class NetCard implements PCI{ public void start() {System.out.print("\n网卡启动");} public void ru
学习笔记---内部类
yang862819503的博客
02-08 280
内部类 1. 成员内部类（普通内部类） 最常见的内部类之一，其定义也很简单，在一个类里面作为类的一个字段直接定义 public class Outer { public class inner{ } } 成员内部类可以访问外部类所有的属性和方法。但是外部类要访问成员内部类的属性和方法，必须要先实例化成员内部类。 注意点：成员内部类里面不能包含静态的属性和方法 package oop.Demo09; public class Outer { public
java实验33 类的继承2_java实验2 类的继承性
weixin_39777464的博客
02-25 693
实验2 类的继承性一、实验目的掌握面向对象的继承性在Java中的实现方法；掌握super关键字的用法，体会抽象类和抽象方法的作用。二、实验内容1.程序理解：1)类的继承2)第4章课后编程第1题class Student {public String name;public int age;public Student(String name,int age){this.name=name;this...
2021-10-20 迈向程序猿的第十步
qq_48654729的博客
10-20 131
目录 一.面向对象三大特性 二.封装 三.继承 3.1 单级继承 3.2 多级继承 3.3 不可继承 3.4 权限 3.5 重写 3.6 super 一.面向对象三大特性 封装 继承 多态(这玩意下次讲) 二.封装 //面向对象案例：车子的发动 //分析： 类： 车类 对象： new 属性：颜色，品牌等 方法：启动 //问题： 价格可以赋值为负数--程序逻辑没问题，但数据不合理 //解决方案：在程序中对属性的值进行判断是否大于0，如果小于0，则给定一个

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值