文章详细介绍了Java中的面向对象特性，包括类、属性、方法的封装，以及继承和多态的概念。此外，还讨论了构造器、静态方法、方法重载、递归和装箱拆箱等编程概念。最后，提到了设计模式的重要性，特别是单例模式的实现。
面向对象
面向对象技术利用对现实世界中对象的抽象和对象之间相互关联及相互作用的描述来对现实世界进行模拟，并且使其映射到目标系统中。其以基本对象模型为单位，将对象内部处理细节封装在模型内部，重视对象模块间的接口联系和对象与外部环境间的联系，能层次清晰地表示对象模型。
面向对象的三大特点：封装 继承 多态
- 抽象（封装）
- 继承
- 多态
java 是单继承，多实现的面向对象的高级语言。
OOP -面向对象程序设计(Object Oriented Programming)
OOD -面向对象设计（Object-Oriented Design，OOD）
AOP-面向切面编程 ( Aspect Oriented Programming)
1.class类
1)了解面向对象 类 对象 属性 方法？
类和对象的概念：
类就是一块模板，确定对象将会拥有的特征（属性）和行为（方法）
具有相同属性和方法的一组对象的集合，就是类，类是抽象的。
声明类、属性、方法、初始化块可以多个、静态块也可以多个
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package cn.practice2;
/**
* <p>Description:类 对象(实例对象) new实例化对象(对象可以使用)</p>
* <p>Class:</p>
* <p>Powered by zxy On 2023/4/17 20:25 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class Demo {
public static void main(String[] args) {
//类 对象(实例对象) new实例化对象(对象可以使用)
User u = new User();
Teacher t = new Teacher();
User.Book book = new User(). new Book();
//User.Book book1 = u.new Book();
}
}
1.1声明类
2)掌握声明类，使用类，导入import 类，实例化对象。
User.java文件有三个类外部类User、Teacher,内部类 User.Book
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package cn.practice2;
/**
* <p>Description:User.java文件有三个类外部类User、Teacher,内部类 User.Book</p>
* <p>Class:User</p>
* <p>Powered by zxy On 2023/4/17 20:15 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class User {
/*初始化程序块*/
{for(int i = 5;i > 0; i--){
System.out.println(i);
}}
/*成员 类 内部类*/
class Book{
}
//对象
//以文件形式管理信息
//属性
int id = 3;
//方法
void pring() {
}
/*静态程序块*/
static {
System.out.println("hello");
}
{
System.out.println("init2");
}
class Teacher{
}
public/*访问修饰权限*/ static/*静态方法，当前方法不用实例化对象，可以通过类型直接使用此方法*/ void/*没有返回值*/ print/*方法名*/(/* 形参列表*/) {
//方法体
//return; 代表结束当前方法执行
}
}
1.2属性方法
访问修饰符
public private protected 保护 默认 friendly
| 访问修饰符 | 本类 | 同包下类 | 子类 | 其他实例对象 |
|---|---|---|---|---|
| private private int id; | √ | |||
| 默认(friendly、default) int id; | √ | √ | ||
| protected protected int id; | √ | √ | √ | |
| public public int id; | √ | √ | √ | √ |
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package cn.practice2;
/**
* <p>Description:属性 成员变量 静态属性 类变量 静态 static 只分配一次内存 常量 不能修改只能使用</p>
* <p>Class:AccessModifier</p>
* <p>Powered by zxy On 2023/4/17 20:54 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class AccessModifier {
/*属性 成员变量*/
public int id; //全局
private final int num = 18;//私有
protected String addr = "郑州";//受保护
String name = "jack";//友好,默认
/* 静态属性 类变量 */
public static int id1 = 3;
//静态 static 只分配一次内存
/*常量 不能修改只能使用*/
public final int AGE = 18;
public static void main(String[] args) {
}
}
1.3方法相关的概念
public/*访问修饰权限*/ static/*静态方法，当前方法不用实例化对象，可以通过类型直接使用此方法*/ void/*没有返回值*/ print/*方法名*/(/* 形参列表*/) {
//方法体
//return; 代表结束当前方法执行
}
无返回值 void修饰 ，方法内部可以使用 return ;随时结束方法执行
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package org.practice;
import cn.practice2.User;
/**
* <p>Description:调用执行方法</p>
* <p>Class:</p>
* <p>Powered by zxy On 2023/4/17 21:45 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class Demo {
public static void main(String[] args) {
for (int i = 10; i > 0; i--) {
User.print();
//hello-user类中的静态输出语句
}
}
}
返回值方法内部必须有 return 值; 用于返回方法指定的类型
方法名称 形参列表 形参列表个数不确定
3)掌握入口方法编写和执行，传参
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package org.practice;
/**
* <p>Description:方法名称 形参列表 形参列表个数不确定</p>
* <p>Class:</p>
* <p>Powered by zxy On 2023/4/17 21:53 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class User {
/*编写一个方法，要求形参个数不确定 参数使用数组 int[] ...*/
public int mysum(int[] ns) {
int s = 0;
for (int t : ns) {
s += t;
}
return s;
}
public int mys(int... n) {
return mysum(n);
}
public static void main(String[] args) {
//调用
User u = new User();
System.out.println(u.mysum(new int[]{}));//0
System.out.println(u.mysum(new int[]{1, 2, 3}));//6
System.out.println(u.mysum(new int[]{1, 6, 10, 2, 3}));//22
System.out.println(u.mys(1, 6, 10, 5, 2, -5, 9, 20, 10, -28));//30
System.out.println(u.mys());//0
}
}
入口方法
一个类中只能写一个入口方法，代表当前类可以独立运行.方法的参数String[]参数。
public static void main(String[] args){
}
int[] a = {10,20,30};
System.out.println(a.length);//3
构造方法
4)方法
入口方法 构造方法 静态方法 重载 递归 装箱 拆箱 静态导入
方法和类名一致，没有返回值，不使用void,此方法不直接通过实例对象调用，此方法在实例化对象时new的时候就开始执行构造方法，在构造方法的第一行代码，默认是super();
注意：如果在编写类的时候编写了构造方法，建议再编写无参构造方法，如果没有编写构造方法，默认给一个无参的构造方法
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package cn.practice2;
/**
* <p>Description:构造方法</p>
* <p>方法和类名一致，没有返回值，不使用void，此方法不直接通过实例对象调用，此方法在实例化对象
* 时new 的时候就开始执行构造方法，在构造方法的第一行代码，默认是super();</p>
* <p>Class:</p>
* <p>Powered by zxy On 2023/4/18 0:24 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class Stu {
public Stu(int id) {
int i = 3;
}
public Stu() {
}
}
设计模式？常用的模式有哪些？请编写单例模式？
什么是设计模式？
解决项目问题经验的总结，很多公司都知晓。
设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结
设计模式的原则？
六大原则：
- 单一原则；
- 里氏替换原则；
- 依赖倒置原则；
- 接口隔离原则；
- 迪米特原则；
- 开闭原则。
常用的设计模式有哪些?
有23种，如单例模式、工厂模式，抽象工厂模式，代理模式…
请用java语言编写单例模式？
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意：
- 1、单例类只能有一个实例。
- 2、单例类必须自己创建自己的唯一实例。
- 3、单例类必须给所有其他对象提供这一实例。
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package org.practice;
/**
* <p>Description:单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一
* 1、单例类只能有一个实例。
* 2、单例类必须自己创建自己的唯一实例。
* 3、单例类必须给所有其他对象提供这一实例。</p>
* <p>Class:Stu</p>
* <p>Powered by zxy On 2023/4/18 0:29 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class Stu {
private Stu() {
}
public static Stu stu;
public static Stu getInstance() {
if (stu == null) {
stu = new Stu();
}
return stu;
}
}
递归方法
在方法内部，再次调用本方法，此方法就是递归方法
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package cn.practice2;
/**
* <p>Description:递归方法-在方法内部，再次调用本方法，此方法就是递归方法</p>
* <p>Class:Recursion</p>
* <p>Powered by zxy On 2023/4/18 0:34 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class Recursion {
static void m1(int i) {
if (i >= 0) {
System.out.println(i);
m1(--i);
}
}
static void m2(int i) {
if (i >= 0) {
m2(--i);
System.out.printf("%d ",i+1);
}
}
public static void main(String[] args) {
System.out.println("---");//6 5 4 3 2 1 0
m1(6);
System.out.println("---");
m2(6);//0 1 2 3 4 5 6
}
}
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package cn.practice2;
/**
* <p>Description:递归方法-输出阶乘-4！</p>
* <p>Class:RecursionFactorial</p>
* <p>Powered by zxy On 2023/4/18 0:38 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class RecursionFactorial {
public static void main(String[] args) {
//factorial() static
//System.out.println(factorial(3));
var d = new RecursionFactorial();
System.out.println(d.factorial(4));
}
int factorial(int n) {
if (n > 1) {
return n * factorial(n - 1);
}
return 1;
}
}
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package cn.practice2;
/**
* <p>Description:递归方法-4！-5！(另外一种方法)-递归排序输出</p>
* <p>Class:</p>
* <p>Powered by zxy On 2023/4/18 0:41 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class RecursionFactorial01 {
public static void main(String[] args) {
//factorial() static
//System.out.println(factorial(3));
var d = new RecursionFactorial();
System.out.println(d.factorial(4));//24
int js = 1;
for (int i = 2; i < 6; i++) {
js *= i;
}
System.out.println("!5 = " + js);//!5 = 120
m1(6);//6 5 4 3 2 1
m2(6);//1 2 3 4 5 6
}
static void m1(int n) {
System.out.println(n);
if (n > 1) m1(n - 1);
}
static void m2(int n) {
if (n > 1) {
m2(n - 1);
}
System.out.println(n);
}
int factorial(int n) {
if (n > 1) {
return n * factorial(n - 1);
}
return 1;
}
}
重载方法
在一个类，或多个继承关系类中，存在方法名称一样，方法参数不一样，此类方法是重载方法。构造方法重载。
/*
* Copyright (c) 2017, 2023, zxy.cn All rights reserved.
*
*/
package cn.practice2;
import static java.lang.Math.random;
import static java.lang.Math.round;
/**
* <p>Description:重载方法-在一个类，或多个继承关系类中，存在方法名称一样，方法参数不一样，
* 此类方法重载方法。构造方法重载</p>
* <p>Class:OverloadedMethod</p>
* <p>Powered by zxy On 2023/4/18 0:44 </p>
*
* @author zxy [zxy06291@163.com]
* @version 1.0
* @since 17
*/
public class OverloadedMethod {
static int sum() {
return 0;
}
static int sum(int a, int b) {
return a + b;
}
static double sum(float a, float b) {
return a + b;
}
static double sum(double a, double b) {
return a + b;
}
public static void show() {
//静态方法
System.out.println("show...");
//使用静态导入
System.out.println(random());
System.out.println(Math.random());
System.out.println(round(1.5));
}
}
静态方法
静态方法，调用执行不用实例化，可以根据类名.方法名()直接调用执行。
在方法内部可以直接调用静态方法，直接使用静态成员 类变量
public static void show() {
System.out.println("show...");
}
静态导入
//自动导入
import static java.lang.Math.random;
import static java.lang.Math.round;
//使用静态导入
System.out.println(random());
System.out.println(Math.random());
System.out.println(round(1.5));
1.4 装箱拆箱
Java中的基本数据类型不是对象型（引用类型）。但是在程序中有时需要对对象而不是基本数据类
型进行操作。因此，java里提供了一种叫做包装类(wrapper)，它能够把基本数据类型包装成对象类型。
Java中的包装器类有两个主要的作用
- 提供一种机制，将基本值“包装”到对象中，从而使基本值能够包含在为对象而保留的操作中，或者从带对象返回值的方法中返回。
- 为基本值提供分类功能。这些功能大多数于各种转换有关：在基本值和String 对象间相互转换，在基本值和String 对象之间按不同基数转换，如二进制、八进制和十六进制等。
| 基本类型 | 包装器类型(对象类型) valueOf() .parse() |
|---|---|
| boolean | Boolean |
| char | Character |
| int | Integer |
| byte | Byte |
| short | Short |
| long | Long |
| float | Float |
| double | Double |
自动装箱和拆箱从Java 1.5开始引入，目的是将原始类型值转自动地转换成对应的对象。
在Java1.5下进行过编程的话，不能直接地向集合(Collections)中放入原始类型值，因为集合只接收对象。将这些原始类型的值转换成对象，然后将这些转换的对象放入集合中。使Integer,Double,Boolean等这些类我们可以将原始类型值转换成对应的对象。
Integer i = 5;//装箱操作
int n = i;//拆箱操作
|
| int | Integer |
| byte | Byte |
| short | Short |
| long | Long |
| float | Float |
| double | Double |
自动装箱和拆箱从Java 1.5开始引入，目的是将原始类型值转自动地转换成对应的对象。
在Java1.5下进行过编程的话，不能直接地向集合(Collections)中放入原始类型值，因为集合只接收对象。将这些原始类型的值转换成对象，然后将这些转换的对象放入集合中。使Integer,Double,Boolean等这些类我们可以将原始类型值转换成对应的对象。
Integer i = 5;//装箱操作
int n = i;//拆箱操作
扫一扫
1637
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
