java面向对象(一)

目录

  • 1.Java面向对象学习的三条主线
  • 2.面向对象与面向过程(人把大象装进冰箱)
      • 2.1面向过程
      • 2.2面向对象
  • 3.面向对象的两个要素:类和对象
    • 3.1类
      • 3.1.1属性
        • 属性 vs 局部变量
      • 3.1.2方法
    • 3.2对象
      • 对象数组
      • 匿名对象
    • 3.3内存解析
  • 4.方法
    • 4.1方法的重载(overload)
    • 4.2可变个数的形参
    • 4.3值传递机制
      • 4.3.1关于变量的赋值
      • 4.3.2方法形参的值传递机制
    • 4.4递归方法
  • 5.封装性(封装和隐藏)
    • 5.1问题的引入
    • 5.2封装性的体现
    • 5.3四种权限修饰符
  • 6.构造器(构造方法)
    • 6.1构造器的作用:
    • 6.2总结属性赋值的先后顺序
  • 7.JavaBean
  • 8.UML类图
  • 9.this关键字
  • 10.package关键字
  • 11.import关键字
  • 12.MVC设计模式

1.Java面向对象学习的三条主线

  1. Java类及类的成员:属性、方法、构造器:代码块、内部类
  2. 面向对象三大特征:封装、继承、多态
  3. 其他关键字:this、super、static、final、abstract、interface、package、import

2.面向对象与面向过程(人把大象装进冰箱)

2.1面向过程

强调功能行为,以函数为最小单位,考虑怎么做。

1.把冰箱门打开
2.抬起大象,塞进冰箱
3.把冰箱门关闭

2.2面向对象

强调具备了功能的对象,以类/对象为最小单位,考虑谁来做。

{
		打开(冰箱){
				冰箱.开开();
		}
		抬起(大象){
				大象.进入(冰箱);
		}
		关闭(冰箱){
				冰箱.闭合();
		}
}
冰箱{
		开开(){}
		闭合(){}
}
大象{
		进入(冰箱){}
}

3.面向对象的两个要素:类和对象

//1.创建类,设计类的成员
class Person{
	//属性
	String name;
	int age;
	boolean isMale;
	//方法
	public void eat(){
		System.out.println("人可以吃饭");
	}
}
//测试类
public class PersonTest{
	public static void main(String[] args){
	//2.创建Person类的对象
		Person p1 = new Person();
		Scaner scanner = new Scanner(System.in);
		//3.调用属性:对象.属性:
		p1.name = "Tom";
		//4.调用方法:对象.方法;
		p1.eat();
	}
}

3.1类

对一类事物的描述,是抽象的、概念上的定义
类的结构:属性、方法

3.1.1属性

对应类中的成员变量,有默认初始化值

属性 vs 局部变量

不同点:
1.在类中声明的位置不同
属性:直接定义在类的一对{}中。
局部变量:声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量。
2.关于权限修饰符(private,public,缺省,protected)的不同
属性:可以在声明属性时,指明其权限(使用权限修饰符)。
局部变量:不可以使用权限修饰符。
3.默认初始化值的情况
属性:类的属性,根据其类型都有默认初始化值
整型(byte,short,int,long):0
浮点型(float,double):0.0
字符型(char):0或 ‘\u0000’
布尔型(boolean):false
引用数据类型(类、数组、接口):null
局部变量:没有默认初始化值。意味着在调用局部变量前要赋初值。
4.在内存中加载的位置
属性(非static):加载到堆空间
局部变量:加载到栈空间

3.1.2方法

对应类中的成员方法
声明:
权限修饰符 返回值类型 方法名(形参列表){
方法体
}

3.2对象

是实际存在的该类事物的每个个体,因而也称为实例

“万事万物皆对象”
1.在java语言范畴中,我们都将功能、结构等封装到类中,通过类的实例化,来调用具体的功能结构。
2.涉及到java语言与前端html、后端数据库交互时,前后端的结构在java层面交互时,都体现类、对象。

对象数组

创建一个Student类,包括学号num(int)、年级state(int)、成绩score(int).
创建20个学生对象,学号为1-20,年级和成绩由随机数确定。
问题一:打印3年级学生信息
问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息

提示:
1.生成随机数:Math.random(),返回值类型为double
2.四舍五入取整:Math.round(double d),返回值类型long

public class demo1 {
    public static void main(String[] args) {
        //声明Student类型的数组
        Student[] st=new Student[20];
        for(int i=0;i<20;i++) {
            //给数组元素赋值
            st[i] = new Student();
            //给Student对象的属性赋值
            st[i].num = i + 1;
            //Math.random()范围[0.0,1.0),返回值为double
            st[i].state = (int) (Math.random() * 6 + 1);
            //System.out.println(st[i].state);
            st[i].score = (int) (Math.random() * 100);
        }
        demo1 d=new demo1();
        d.search(st,3);
        d.sort(st);
    }
    //查找指定年级的学生信息
    public void search(Student st[],int sta){
        for(int i=0;i<st.length;i++){
            if (st[i].state == sta) System.out.println(st[i].Info());
        }
    }
    //对学生成绩使用冒泡排序按从低到高排序
    public void sort(Student st[]){
        for(int i=0;i<st.length-1;i++){
            for(int j=0;j<st.length-1-i;j++){
                if(st[j].score>st[j+1].score){
                    Student temp=st[j];
                    st[j]=st[j+1];
                    st[j+1]=temp;
                }
            }
        }
        print(st);
    }
    //输出学生信息
    public void print(Student st[]){
        for(int i=0;i<st.length;i++){
            System.out.println(st[i].Info());
        }
    }
}
class Student{
    int num;//学号
    int state;//年级
    int score;//成绩
    String Info(){
        return ("学号:"+num+" 年级:"+state+" 成绩:"+score);
    }
}

匿名对象

在上面代码的基础上

new Student().num=10;
new Student().Info();

理解:创建的对象没有显式的赋给一个变量名,即为匿名对象。
特点:匿名对象只能调用一次。每次new一个对象都是新的对象。
使用:往往在方法调用使用,作为参数传进去。

3.3内存解析

在这里插入图片描述
对象的内存解析:
在这里插入图片描述
引用类型的变量,只可能存储两类值:null和地址值。

4.方法

4.1方法的重载(overload)

概念:在同一个类中,允许存在一个以上的同名方法,只要他们的参数个数或者参数类型不同即可。
与权限修饰符、返回值类型、形参变量名无关。
System.out.println()就是一个典型的重载方法。

4.2可变个数的形参

是jdk5.0新增内容

public class demo2 {
    public static void main(String[] args) {
        demo2 d=new demo2();
        d.show(1);
        d.show("h");
        d.show("h1","h2");
        d.show();
        d.show(new String[]{"aa","bb","cc"});
    }
    public void show(int i){}
    public void show(String s){}
    //可变个数的形参举例
    public void show(String ...str){
    for(int i=0;i<str.length;i++){
            System.out.println(str[i]);
        }
	}
    public void show(String[] str){}//与上一个方法不能同时存在,因为它们是相同的方法,不构成重载
}

可变个数的形参格式:数据类型…变量名
形参个数可以为0到任意个。
可变个数的形参方法,与本类方法中方法名相同、形参不同的方法,构成函数重载。
可变个数形参在方法的形参中只能声明在末尾:

public void show(int i,String...str){}

应用:在数据库查询时可能用到。

4.3值传递机制

4.3.1关于变量的赋值

1.变量是基本数据类型
此时赋值的是变量所保存的数据值。

int m=1;
int n=m;
n=2;
//此时m为1,n为2

2.变量是引用数据类型
此时赋值的是变量所保存的地址值。

//Order为一个类,有属性num
Order o1=new Order();
o1.num=1001;
Order o2=o1;
o2=1002;
//此时o1和o2都是1002

4.3.2方法形参的值传递机制

1.形参是基本数据类型,此时实参赋给形参的是实参真实存储的数据值。

public class demo3 {
    public static void main(String[] args) {
        int m=10;
        int n=20;
        demo3 d=new demo3();
        d.swap(m,n);
        System.out.println("m="+m+" n="+n);//输出m=10 n=20
    }
    public void swap(int m,int n){
        int swap=m;
        m=n;
        n=swap;
    }
}

内存解析:
在这里插入图片描述
swap()调用结束后,栈中swap()的局部变量释放(出栈),在main()中输出的m,n仍是栈中的m,n的值。
2.参数是引用数据类型,此时实参赋给形参的是实参存储数据的地址值。
在这里插入图片描述
左边为栈,右边为堆。
栈底data为main()中的data.
swap()调用结束后,栈顶temp和data出栈,栈中只剩下main()中的data,此时data指向堆中已经修改后的对象。因此成功交换m,n

4.4递归方法

一个方法体内调用它的自身。
例1:已知有一个数列,f(0)=1,f(1)=4,f(n+2)=2*f(n+1)+f(n),其中n是大于0的整数,求f(10)的值。

public class demo4 {
    public static void main(String[] args) {
        demo4 d=new demo4();
        System.out.println(d.digui(10));//输出10497
    }
    public int digui(int n){
        if(n==0)return 1;
        else if(n==1)return 4;
        else{
            return 2*digui(n-1)+digui(n-2);
        }
    }
}

例2:输出斐波那契数列第n个数

public class demo5 {
    public static void main(String[] args) {
        demo5 d=new demo5();
        System.out.println(d.digui(10));
    }
    public int digui(int n){
        if(n==1||n==2)return 1;
        else{
            return digui(n-1)+digui(n-2);
        }
    }
}

5.封装性(封装和隐藏)

程序设计追求“高内聚,低耦合”。
高内聚:类的内部数据操作细节自己完成,不允许外部干涉。
低耦合:仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性,只对外公开简单的接口()。便于外界调用,从而提高系统的可扩展性、可维护性。

5.1问题的引入

当我们创建一个类的对象以后,我们可以通过“对象.属性”的方式对属性进行赋值。这里,赋值操作要受到属性的数据结构和存储范围的制约。除此之外,没有其他制约条件。
但是,在实际问题中,我们往往需要给属性的赋值加入额外的限制条件。这个条件就不能在属性声明时体现,我们只能通过方法进行限制条件的添加。
限制了用户再使用“对象.属性”的方式。

5.2封装性的体现

1.将类的属性(xxx)私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值。

public class AnimalTest {
    public static void main(String[] args) {
        Animal an=new Animal();
        an.name="小狗";
        an.age=1;
        an.setLegs(4);
        an.getLegs();
        an.print();
    }
}
class Animal{
    String name;
    int age;
    private int legs;//动物腿的条数
    //限制对动物腿数的赋值
    public void setLegs(int l){
        if(l>=0&&l%2==0) legs=l;
        else legs=0;
    }
    //获取动物腿的个数
    public int getLegs(){
        return legs;
    }
    public void print(){
        System.out.println("name:"+name+" age:"+age+" legs:"+legs);
    }
}

2.将类的方法私有化,仅供类内使用
3.单例模式
……

5.3四种权限修饰符

权限从小到大:private、缺省、protected、public

修饰符类内部同一个包不同包的子类同一个工程
privateyes
缺省yesyes
protectedyesyesyes
publicyesyesyesyes

四种权限可以修饰类,和类的内部结构:属性、方法、构造器、内部类。
只能使用缺省和public修饰类,但是四种权限都可以修饰类的内部结构(属性、方法、构造器、内部类)。

为什么不能用protected修饰类?
因为如果类能被protected修饰,那么这个类就一定是子类,也就是内部类,内部类可以被四种权限修饰符修饰。但是原本的问题中这个类并不是内部类。

6.构造器(构造方法)

定义构造器的格式:权限修饰符 类名(形参列表){}
一个类中的多个构造器,彼此构成重载。

注意:
如果没有显式的定义类的构造器,则系统默认提供一个空参的构造器,此默认构造器的权限和该类的权限相同。
一旦显式的定义了类的构造器,系统就不再提供默认的空参构造器。
一个类中至少存在一个构造器,可以是默认的,也可以是自己定义的。

6.1构造器的作用:

1.创建对象

public class PersonTest {
    public static void main(String[] args) {
        Person p=new Person();//Person()就是构造器,是系统提供的默认的空参构造器
        p.setAge(12);
    }
}
public class Person {
    private int age;
    public void setAge(int a){
        age=a;
    }
    public int getAge(){
        return age;
    }
}

2.初始化对象的信息

public class PersonTest {
    public static void main(String[] args) {
        Person p=new Person("Tom");
    }
}
public class Person {
    private int age;
    String name;
    //构造器
    public Person(){
    	System.out.println("Person()");
	}
	public Person(String n){
		name=n;
	}
}

6.2总结属性赋值的先后顺序

1.默认初始化值
2.显式初始化
3.构造器赋值
4.通过“对象.方法”或“对象.属性”的方式赋值

以上操作执行的先后顺序:1 -> 2 -> 3 -> 4

7.JavaBean

JavaBean是一种java语言写成的可重用组件

JavaBean是符合以下标准的java类:
1.类是公共的
2.有一个无参的公共构造器
3.有属性,且有对应的get、set方法

……待更

8.UML类图

在这里插入图片描述

9.this关键字

public class Person {
    private int age;
    public void setAge(int age){
    	//this可理解为当前对象
        this.age=age;
    }
    public int getAge(){
   		//可写为return this.age;
        return age;
    }
    public Person(int age){
    	this.age=age;
    }
    public void eat(){
        System.out.println("eat");
        this.sleep();//this.可省略
    }
    public void sleep(){
        System.out.println("sleep");
    }
}

this关键字的使用:
1.this可以修饰属性、方法、构造器。
2.this可理解为当前的对象或当前正在创建的对象。
3.在类的方法中,可以使用"this.属性"或"this.方法"的方式,调用当前对象的属性或方法。
但是,通常情况下我们都选择省略"this."
特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。
4.在类的构造器中,可以使用"this.属性"或"this.方法"的方式,调用当前正在创建的对象的属性或方法。
但是,通常情况下我们都选择省略"this."
特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。
5.this调用构造器
在类的构造器中,可以显式的使用this(形参列表)方式,调用类中指定的其他构造器。
构造器中不能通过this(形参列表)方式调用自己
如果一个类中共有N个构造器,那么最多有N-1个构造器中使用this(形参列表)
规定:this(形参列表)必须声明在当前构造器的首行。

public class Person {
    private int age;
    String name;
       public Person(){
        age=18;
        //Person类初始化时,需要考虑如下的条件(假设还有四十行代码
    }
    public Person(int age){
        this();//调用空参构造器
        this.age=age;
    }
    public Person(String name,int age){
        this(age);//调用上一个构造器
        this.name=name;
    }
}

10.package关键字

package cn.demo.day.day02;

为了更好的实现项目中类的管理,提供了包的概念。
使用package声明类或者接口所属的包,声明在源文件的首行。
包属于标识符,需要遵循标识符命名的规范。
每 “.” 一次,就代表一层文件目录。

补充:同一个包下,不可以命名同名的接口、类。

11.import关键字

作用:在源文件中显式的使用import结构导入指定包下的类、接口
声明在包的声明和类的声明之间。
如果需要导入多个结构,则并列写出即可。

import xxx.*;//表示可以导入xxx包下的所有结构
import java.lang;//可以省略

如果使用的类或接口是本包下定义的,则可以省略import结构。
如果在源文件中,使用了不同包下的同名的类,则必须至少有一个类需要以全类名的方式显示。
如果使用“xxx.*”方式表明可以调用xxx包下的所有结构。但是若使用xxx子包下的结构,则只能显式的导入。

import static表示导入指定类或接口中的静态结构(属性或方法)。
如:

import static java.long.System.* ;
import static java.long.Math.*;
out.println("hi");//System.out.println("hi");
long num=round(123.123);//long num=Math.round(123.123);

12.MVC设计模式

在这里插入图片描述

热门文章

暂无图片
编程学习 ·

Java输出数组的内容

Java输出数组的内容_一万个小时-CSDN博客_java打印数组内容1. 输出内容最常见的方式// List<String>类型的列表List<String> list new ArrayList<String>();list.add("First");list.add("Second");list.add("Third");list.ad…
暂无图片
编程学习 ·

母螳螂的“魅惑之术”

在它们对大蝗虫发起进攻的时候&#xff0c;我认认真真地观察了一次&#xff0c;因为它们突然像触电一样浑身痉挛起来&#xff0c;警觉地面对限前这个大家伙&#xff0c;然后放下自己优雅的身段和祈祷的双手&#xff0c;摆出了一个可怕的姿势。我被眼前的一幕吓到了&#xff0c;…
暂无图片
编程学习 ·

疯狂填词 mad_libs 第9章9.9.2

#win7 python3.7.0 import os,reos.chdir(d:\documents\program_language) file1open(.\疯狂填词_d9z9d2_r.txt) file2open(.\疯狂填词_d9z9d2_w.txt,w) words[ADJECTIVE,NOUN,VERB,NOUN] str1file1.read()#方法1 for word in words :word_replaceinput(fEnter a {word} :)str1…
暂无图片
编程学习 ·

HBASE 高可用

为了保证HBASE是高可用的,所依赖的HDFS和zookeeper也要是高可用的. 通过参数hbase.rootdir指定了连接到Hadoop的地址,mycluster表示为Hadoop的集群. HBASE本身的高可用很简单,只要在一个健康的集群其他节点通过命令 hbase-daemon.sh start master启动一个Hmaster进程,这个Hmast…
暂无图片
编程学习 ·

js事件操作语法

一、事件的绑定语法 语法形式1 事件监听 标签对象.addEventListener(click,function(){}); 语法形式2 on语法绑定 标签对象.onclick function(){} on语法是通过 等于赋值绑定的事件处理函数 , 等于赋值本质上执行的是覆盖赋值,后赋值的数据会覆盖之前存储的数据,也就是on…
暂无图片
编程学习 ·

Photoshop插件--晕影动态--选区--脚本开发--PS插件

文章目录1.插件界面2.关键代码2.1 选区2.2 动态晕影3.作者寄语PS是一款栅格图像编辑软件&#xff0c;具有许多强大的功能&#xff0c;本文演示如何通过脚本实现晕影动态和选区相关功能&#xff0c;展示从互联网收集而来的一个小插件&#xff0c;供大家学习交流&#xff0c;请勿…
暂无图片
编程学习 ·

vs LNK1104 无法打开文件“xxx.obj”

写在前面&#xff1a; 向大家推荐两本新书&#xff0c;《深度学习计算机视觉实战》和《学习OpenCV4&#xff1a;基于Python的算法实战》。 《深度学习计算机视觉实战》讲了计算机视觉理论基础&#xff0c;讲了案例项目&#xff0c;讲了模型部署&#xff0c;这些项目学会之后可以…
暂无图片
编程学习 ·

工业元宇宙的定义与实施路线图

工业元宇宙的定义与实施路线图 李正海 1 工业元宇宙 给大家做一个关于工业元宇宙的定义。对于工业&#xff0c;从设计的角度来讲&#xff0c;现在的设计人员已经做到了普遍的三维设计&#xff0c;但是进入元宇宙时代&#xff0c;就不仅仅只是三维设计了&#xff0c;我们的目…
暂无图片
编程学习 ·

【leectode 2022.1.15】完成一半题目

有 N 位扣友参加了微软与力扣举办了「以扣会友」线下活动。主办方提供了 2*N 道题目&#xff0c;整型数组 questions 中每个数字对应了每道题目所涉及的知识点类型。 若每位扣友选择不同的一题&#xff0c;请返回被选的 N 道题目至少包含多少种知识点类型。 示例 1&#xff1a…
暂无图片
编程学习 ·

js 面试题总结

一、js原型与原型链 1. prototype 每个函数都有一个prototype属性&#xff0c;被称为显示原型 2._ _proto_ _ 每个实例对象都会有_ _proto_ _属性,其被称为隐式原型 每一个实例对象的隐式原型_ _proto_ _属性指向自身构造函数的显式原型prototype 3. constructor 每个prot…
暂无图片
编程学习 ·

java练习代码

打印自定义行数的空心菱形练习代码如下 import java.util.Scanner; public class daYinLengXing{public static void main(String[] args) {System.out.println("请输入行数");Scanner myScanner new Scanner(System.in);int g myScanner.nextInt();int num g%2;//…
暂无图片
编程学习 ·

RocketMQ-什么是死信队列?怎么解决

目录 什么是死信队列 死信队列的特征 死信消息的处理 什么是死信队列 当一条消息初次消费失败&#xff0c;消息队列会自动进行消费重试&#xff1b;达到最大重试次数后&#xff0c;若消费依然失败&#xff0c;则表明消费者在正常情况下无法正确地消费该消息&#xff0c;此时…
暂无图片
编程学习 ·

项目 cg day04

第4章 lua、Canal实现广告缓存 学习目标 Lua介绍 Lua语法 输出、变量定义、数据类型、流程控制(if..)、循环操作、函数、表(数组)、模块OpenResty介绍(理解配置) 封装了Nginx&#xff0c;并且提供了Lua扩展&#xff0c;大大提升了Nginx对并发处理的能&#xff0c;10K-1000K Lu…
暂无图片
编程学习 ·

输出三角形

#include <stdio.h> int main() { int i,j; for(i0;i<5;i) { for(j0;j<i;j) { printf("*"); } printf("\n"); } }
暂无图片
编程学习 ·

stm32的BOOTLOADER学习1

序言 最近计划学习stm32的BOOTLOADER学习,把学习过程记录下来 因为现在网上STM32C8T6还是比较贵的,根据我的需求flash空间小一些也可以,所以我决定使用stm32c6t6.这个芯片的空间是32kb的。 #熟悉芯片内部的空间地址 1、flash ROM&#xff1a; 大小32KB&#xff0c;范围&#xf…
暂无图片
编程学习 ·

通过awk和shell来限制IP多次访问之学不会你打死我

学不会你打死我 今天我们用shell脚本&#xff0c;awk工具来分析日志来判断是否存在扫描器来进行破解网站密码——限制访问次数过多的IP地址&#xff0c;通过Iptables来进行限制。代码在末尾 首先我们要先查看日志的格式&#xff0c;分析出我们需要筛选的内容&#xff0c;日志…
暂无图片
编程学习 ·

Python - 如何像程序员一样思考

在为计算机编写程序之前&#xff0c;您必须学会如何像程序员一样思考。学习像程序员一样思考对任何学生都很有价值。以下步骤可帮助任何人学习编码并了解计算机科学的价值——即使他们不打算成为计算机科学家。 顾名思义&#xff0c;Python经常被想要学习编程的人用作第一语言…
暂无图片
编程学习 ·

蓝桥杯python-数字三角形

问题描述 虽然我前后用了三种做法&#xff0c;但是我发现只有“优化思路_1”可以通过蓝桥杯官网中的测评&#xff0c;但是如果用c/c的话&#xff0c;每个都通得过&#xff0c;足以可见python的效率之低&#xff08;但耐不住人家好用啊&#xff08;哭笑&#xff09;&#xff09…