- 面向对象思想
package com.uncle.object_oriented;
/**
* 面向对象
*
* 面向过程的编程思想
* 解决问题的时候按照一定的过程(流程)
* 钟点工---> 大象装冰箱 总共分几步
* 1.开门 2.大象装里面 3.关门
* 以过程为本--复用--增加了很多冗余
* 大段的过程 拆分成小段 --- 到底是哪一个实体来做的
* 面向对象的编程思想
* 解决问题的时候按照现实生活中的规律来考虑问题
* 考虑在这个问题的过程中 有几个实体参与进来
* 理解为 实体动作动作的支配者 没有实体动作就发生不了
* 人 冰箱 大象
* 分析每一类个体都有什么特点 做了哪些事情
* 大象 特点 大 体重很重
* 冰箱 特点 有门 容积
* 人 特点 能做事情 做了哪些事情呢 ? 开冰箱门 装大象 关门
*
*
* 类和对象
* 类----人类 抽象笼统的概念 描述一类事物 肯定是具有相同的特征行为
* 人类有名字 有年龄 有性别-----静态描述特征(特征)-----属性
* 人类能吃饭 能说话 能学习-----动态动作行为(做事)-----方法
* 对象--具体的人 人类中的一个具体的人 郑中拓
* 大叔这个具体的人 有名字 有年龄 有性别
* 能吃饭 能说话 能学习
*
* 在现实生活中 对象是先有的 总结出来的概念(类) 后产生的
* 在计算机中利用面向对象的思想来做事
* 需要先自己定义(描述)一个类(型)
* 想要做事情 需要在描述的类中创建一个具体的个体(对象)出来
* 个体(对象)来做事
*
* 如何在计算机中创建(描述)一个类
* 1.先创建一个类class
* 2.类的里面 利用属性或方法去描述这个类
* 3.创建一个当前类的对象 让对象调用属性/方法做事
* 对象的创建在哪儿都可以
*
* 类中的方法---->做一件事情
* 权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数列表) [抛出异常] [{
* 方法体
* }]
* 权限修饰符 返回值类型 方法名字 (参数列表) {
*
* }
* 1.无参数无返回值
* 2.无参数有返回值
* 3.有参数无返回值
* 4.有参数有返回值
*
* 人类有名字 有年龄 有性别----属性
* 人类能吃饭 能说话 能学习----方法
*
* 可以理解为方法是做了一件事情
* 可以理解为返回值是这件事情做完了 留下的一个结果
* 可以理解为参数是做事情之前 必须提供的条件
*
* 形参和实参
* 形参可以理解为是方法执行时的临时变量空间 x
* 实参可以理解为是方法调用时传递进去的参数 a
* 方法调用时会将实参的内容传递给形参
* 如果内容是基本类型 传递的 是值 形参改变 实参不变
* 如果内容是引用类型 传递的 是引用 形参改变 实参跟着改变
*
*
* 命名规则和规约
* 规则
* 字母 数字 符号 中文
* 字母 区分大小写
* 数字 不能开头
* 符号 _ $
* 中文 不推荐使用
* 规约
* 类名字 首字母大写 两个单词以上 每一个首字母都大写
* Test TestOne TestOneTwo
* 属性/方法/变量 驼峰式命名规约 首字母小写 两个单词以上 第二个以后的每一个首字母大写
* test testOne testOneTwo
* 构造方法 与类名一致 类中唯一的大写字母开头的方法
* 静态常量 全部字母大写 通过_做具体说明 BOOKSTORE_ADMIN
* 包名 全部字母小写 Java关键字都是小写 注意与关键字不要冲突
* 所有的名字最好--->见名知意(增强可读性 层次关系缩进 见名知意 注释)
*/
public class ObjectOriented {
//这个文件是在计算机内 画的一张图纸
//描述计算机里的人类长成什么样子
//属性--静态描述特点
// 必要的组成部分
// 修饰符 数据类型 属性名字 [= 值];
public String name;
public String sex;
public ObjectOriented() {
}
public ObjectOriented(String name, String sex) {
this.name = name;
this.sex = sex;
}
//重写toString方法 为了方便打印 后面会讲
@Override
public String toString() {
return "ObjectOriented{" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
'}';
}
public String eat(String food) {
System.out.println(name+"吃了"+food);
return "方法调用成功";
}
class Person {
//这个文件是在计算机内 画的一张图纸
//描述计算机里的人类长成什么样子
//属性--静态描述特点
// 必要的组成部分
// 权限修饰符 [特征修饰符] 数据类型 属性名字 [= 值];
public String name;//全局变量
public int age;
public String sex;//
//*方法--描述可以做什么事情(动作)
//设计一个方法 用来描述人类可以做吃饭这件事情
public void eat(){
System.out.println("吃了一碗大米饭");
}
//设计一个方法 用来告诉别人我的名字 "郑中拓"
//若方法的设计规定了返回值类型 方法内必须通过return关键字返回一个值
public String tellName(){
System.out.println("你们问我叫什么呀？勉强告诉你们一下");
return "郑中拓";//只有一个
}
//设计一个新的吃饭方法
//描述人类可以做吃饭饭这件事情
public void chiFanFan(int count,String something){
System.out.println("吃了"+count+"碗"+something);
}
//设计一个方法 买饮料 1.需不需要提供条件 2.需不需要给别人留下什么结果
// 需要提供条件 钱
// 需要返回值 买到的饮料 名字
public String buyDrink(int money){
if(money>5){
return "红牛";
}else{
return "矿泉水";
}
}
//设计一个方法 用来画星星 4*4
//f-->表示方向的意思 f==true 偏左 没有空格 f==false 偏右 带空格
public void drawStar(int line,boolean f){
for(int i=1;i<=line;i++){
if(!f){//f==false 偏右 带空格
for(int j=1;j<=line-i;j++){
System.out.print(" ");
}
}
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
public static void main(String[] args) {
ObjectOriented objectOriented = new ObjectOriented();
objectOriented.name = "步尔斯特";
objectOriented.sex = "男";
System.out.println(objectOriented.toString());
objectOriented.eat("米饭");
}
}
/*
类----抽象笼统的概念 Person
具有一组相同的特征或行为
属性---静态描述类的特征
权限修饰符 [特征修饰符] 属性类型 属性名字 [= 值];
方法---动态描述类的行为
权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数列表) [抛出异常] [{
方法执行体
}]
方法中最主要的两个结构 方法的参数列表 方法的返回值类型
参数列表可以理解为方法做事情之前需要提供的条件(可以多个)
返回值可以理解为方法做事情之后得到的一个结果(只有一个)
类描述好了以后是不可以直接做事情
需要创建当前类的对象 通过new的方式
Person p = new Person();
通过p.调用啦 调用属性(存值/取值) 调用方法(执行一次)
*/
- 练习
package com.uncle.object_oriented;
public class TestFunctions {
//8.设计一个方法 用来存储给定范围内的素数(2-100) 素数在自然数之内
// 是否需要提供条件 begin end 返回值一个装满了素数的数组
public int[] findPrimeNum(int begin,int end){
if(begin<0 || end<0){
System.out.println("素数没有负数 不给你找啦");
return null;//自定义一个异常 认为规定的一种不正常的现象
}
if(begin>=end){
System.out.println("您提供的范围有误 begin应该比end要小");
return null;//自定义一个异常 认为规定的一种不正常的现象
}
//创建一个足够长的数组
int[] array = new int[(end-begin)/2];
int index = 0;//记录新数组的索引变化 同时记录个数
for(int num=begin;num<=end;num++){
boolean b = false;//标记
for(int i=2;i<=num/2;i++){
if(num%i==0){
b = true;
break;
}
}
if(!b){
array[index++] = num;
}
}
//将数组后面的多余的0去掉
int[] primeArray = new int[index];
for(int i=0;i<primeArray.length;i++){
primeArray[i] = array[i];
}
array = null;
return primeArray;
}
//扩展 设计一个方法 将给定的元素插入数组的某一个位置
//7.设计一个方法 用来去掉数组中的0元素
// 需要提供参数一个数组 需要提供删除的元素是什么 返回值 一个新的数组
public int[] removeElementFromArray(int[] array,int element){
//找寻原数组中去掉被删除元素后的长度
int count = 0;//记录非删除元素的个数
for(int i=0;i<array.length;i++){
if(array[i]!=element){
count++;
}
}
//通过找到的count创建一个新数组
int[] newArray = new int[count];
int index = 0;//控制新数组的索引变化
//将原来数组中非删除的元素存入新数组中
for(int i=0;i<array.length;i++){
if(array[i]!=0){
newArray[index++] = array[i];
}
}
//将新数组返回
return newArray;
}
//5.设计一个方法 用来合并两个数组
// 是否需要参数 需要提供两个数组 需要返回一个大的数组
public int[] mergeArray(int[] a,int[] b){
//创建一个新的数组
int[] newArray = new int[a.length+b.length];
//分别将a和b数组的元素存入新数组内
for(int i=0;i<a.length;i++){
newArray[i] = a[i];
}
for(int i=0;i<b.length;i++){
newArray[a.length+i] = b[i];
}
//将新数组返回
return newArray;
}
//6.设计一个方法 用来将一个数组按照最大值位置拆分
// 需要提供一个大的数组 需要返回值二维数组
public int[][] splitArray(int[] array){// 1 2 3 9 4 5
//找寻最大值索引位置
int max = array[0];//记录最大值
int index = 0;//记录最大值的索引位置
for(int i=1;i<array.length;i++){
if(array[i]>max){
max = array[i];
index = i;
}
}
//通过找寻到的index判定数组拆分后的前后长度
int[] newa = new int[index];
int[] newb = new int[array.length-index-1];
//分别将两个小数组填满
for(int i=0;i<newa.length;i++){
newa[i] = array[i];
}
for(int i=0;i<newb.length;i++){
newb[i] = array[(index+1)+i];
}
//将两个新的小数组一起返回
return new int[][]{newa,newb};
}
//4.设计一个方法 用来找寻给定的元素是否在数组内存在(Scanner输入一个)
// 是否需要参数及返回值 需要提供一个数组 需要一个目标元素 返回值告诉你是否找到啦
// 方法设计了返回值类型 就必须给返回值 编译检测的悲观性原则
public String isExist(int[] array,int element){
//循环方式找寻是否存在
String result = "对不起 您要的值在数组中没有";
for(int i=0;i<array.length;i++){
if(array[i]==element){
result = "恭喜您 您要的值在数组中存在";
break;
}
}
return result;
}
//3.设计一个方法 用来寻找数组中的极值(最大值 或 最小值)
// 是否需要参数及返回值 需要提供一个数组 需要提供一个值(最大 最小) 返回值肯定需要一个值
public int findMaxOrMinNum(int[] array,boolean flag){//flag==true最大值 flag==false最小值
//2.找一个变量
int temp = array[0];
//3.利用遍历数组的方式挨个与max比较
for(int i=1;i<array.length;i++){
if(flag && array[i]>temp){//找寻最大值
temp = array[i];
}else if(!flag && array[i]<temp){//找寻最小值
temp = array[i];
}
}
//3.将找到的值返回
return temp;
}
//*2.设计一个方法 用来交换一个数组(头尾互换)
// 是否需要参数及返回值 需要提供一个数组 不需要返回值
public void changeArrayElements(int[] array){
//2.数组内部的元素头尾对应互换
for(int i=0;i<array.length/2;i++){
int temp = array[i];
array[i] = array[array.length-1-i];
array[array.length-1-i] = temp;
}
}
}
package com.uncle.object_oriented;
public class Test {
public static void main(String[] args){
//隐藏的过程 加载类
//0.创建一个对象
TestFunctions tf = new TestFunctions();
int[] x = tf.findPrimeNum(100,10);
for(int v:x){
System.out.println(v);
}
//找寻给定元素是否在数组中存在
// int[] x = new int[]{1,2,3,4,5,6};
// String result = tf.isExist(x,14);
// System.out.println(result);
//找寻最大值或最小值
// //1.有一个数组
// int[] array = new int[]{1,3,5,7,9,0,8,6,4,2};
// //2.调用tf中的方法 做事
// int result = tf.findMaxOrMinNum(array,false);//array数组中找寻最大值
// //4.验证一下
// System.out.println("数组中的最大值为:"+result);
//交换数组内部元素
// //1.有一个数组
// int[] x = new int[]{1,2,3,4,5,6,7,8,9};
// //2.利用tf对象调用方法执行操作
// tf.changeArrayElements(x);//x--->array
// //3.验证看一看结果
// for(int v:x){
// System.out.println(v);
// }
}
}
- 类加载及创建（基本类型）
- 方法参数及返回值传递
- 类加载及创建（引用类型）
- 数组互换方式一
- 数组互换方式二
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
