这么细的类和对象，确定不来看看？

文章目录

类是一种自定义类型，就像是一个模板

对象就像是实体

通过一个类就可以产生多个对象

面向对象的概念OOP

面向对象是思考问题的一种思考方式，是一种思想。比如：概念与实例。理论与实践。名和实等等

类就是一类对象的统称。对象就是这一类具体化的一个实例。
面向对象的好处：将复杂的事情变简单了，只要面对一个对象就行。

面向对象：找对象、创对象、使用对象

面向对象OOP的3个比较重要的思想：封装继承多态

实例：

面向过程： 1.把冰箱打开 2. 把大象放入 3. 冰箱关起来

面向对象：打开冰箱，储存、关闭都是对冰箱的操作，是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

Java就是一门面向对象的语言

类的定义方式及成员访问

类名是大驼峰

classPerson{//类就是一种自定义类型//字段--成员变量（定义在方法外面，类的里面）//实例成员变量放在对象里面，而对象在堆上面//实例成员变量没有初始化，就是默认的0值，引用类型是null，基本类型就是0，其中char的默认值是'\u000' //boolean的默认值是falsepublicString name;publicint age;//静态成员变量--也叫类变量  也是符合上面的默认值规则  //静态成员变量不依赖于对象，属于方法区，所以打印的时候写类名.静态成员变量//静态的东西只会在方法区开辟一份，而下面的per会重复开辟 publicstaticint b=20;//方法--行为publicint a=10;//局部变量--定义在方法里面,局部变量一定要初始化，而成员变量可以不初始化  publicvoideat(){System.out.println("eat");}publicvoiddrink(){System.out.println("drink");}publicstaticvoidfunc(){//静态的方法  System.out.println("func");}}publicclassClass1{publicstaticvoidmain(String[] args){//实例化一个对象  通过关键字newPerson per =newPerson();//此时Person就是一种自定义类型，per是叫做引用变量
        per.eat();
        per.drink();System.out.println(per.age);System.out.println(per.name);System.out.println(Person.b);//静态成员变量不依赖于对象，直接  类名.静态成员变量Person.func;//调用静态的方法也是直接  类名.静态成员变量}}//注意：Person就是类名//      per就是对象，也叫引用变量 //实例成员变量是属于对象的，而静态的成员变量不依赖于对象，所以可以不创建对象，直接使用类名.静态的成员变量名/方法名

上图，类Person就像一个模板，per和 person2都是对象，都可以使用Person这个类

注意：

1.静态成员变量只能定义在方法外面，不能在方法里面定义

2.静态的方法里面不可以定义普通的方法，普通的方法里面可以定义静态的方法

这是因为静态的不依赖于对象，而普通的依赖于对象，所以静态的方法里面不可以定义普通的方法

访问修饰限定符

public 共有的

private 私有的

protected 受保护的

default 什么都不写默认权限 --包访问权限

引用类型包括String Array……

static 关键字

1、修饰属性
2、修饰方法
3、代码块(后面在写)
4、修饰类(后面讲内部类会学到)

1.修饰属性

classTestDemo{//类名是TestDemopublicint a;//实例成员变量publicstaticint count;//静态成员变量 }publicclassClass1{publicstaticvoidmain(String[] args){TestDemo t1 =newTestDemo();
            t1.a++;//1TestDemo.count++;//1System.out.println(t1.a);System.out.println(TestDemo.count);System.out.println("============");TestDemo t2 =newTestDemo();
            t2.a++;//1TestDemo.count++;//2System.out.println(t2.a);System.out.println(TestDemo.count);}//t1  t2是类的对象    //实例成员变量只要new一次就要重新创建一次，堆上的数据就会消失//静态成员变量放在方法区上，而且只会生成一次，所以具有记忆性

2.修饰方法

classTestDemo{//类名是TestDemopublicint a;//实例成员变量publicstaticint count;//静态成员变量publicstaticvoidfunc(){//静态方法System.out.println("func");
        a=12;//err
        count=23;//静态方法内部不能调用非静态的数据成员，只能调用静态的成员变量或静态方法//因为静态成员不依赖于对象 所以可以直接调用静态方法}}

所以之前写方法要加上static，因为这样就可以不用实例化一个对象就可以直接调用方法

publicclassClass1{publicstaticvoidfun1(){//……}publicstaticvoidfun2(){//……}publicstaticvoidmain(String[] args){fun1();//直接调用静态方法//同样的效果：Class1 pc =newClass1();//要使用普通的方法就要先定义一个对象pc，再调用fun2，麻烦Class1.fun2();}

总结：所有被static所修饰的方法或者属性，全部不依赖于对象。

封装（要配合接口）

封装：用private修饰属性（字段）或者方法，同时提供pubiic方法给类的调用者使用

封装的好处：私有的数据成员在类外就不能被调用，更加安全

加上了private，就要提供get 和 set的接口来使之可以被访问

classStudent{privateStringMyname;//加上private就是封装---限定Myname只能在类中使用publicint age;//提供一个获得name的接口publicStringgetMyname(){returnMyname;//返回值是String}//修改Myname的接口publicvoidsetMyname(String name){Myname= name;}publicvoidfunc(){System.out.println("func1");}}publicclassTestDemo2{publicstaticvoidmain(String[] args){Student stu =newStudent();//定义一个对象
           stu.setMyname("deng");System.out.println(stu.getMyname());}}//提供两个接口，是为了在类的外面设置并使用被封装的变量//使用了封装，就不用关心类里面的变量命名，只要关注调用接口的名字就行了

自动补全接口

光标放在类里面，alt + insert就会出现getter和setter ，往下找到getter和 setter，shift+下键选中即可，而且还有自动加上this，十分方便

关键字: this

this: 当前对象的引用

classStudent{privateStringMyname;//加上private就是封装---限定Myname只能在类中使用privateint age;//提供一个获得name的接口publicStringgetMyname(){returnthis.Myname;//返回值是String}//修改如下：//修改Myname的接口publicvoidsetMyname(StringMyname){this.Myname=Myname;}//要是不加this就会打印null，其实就是自己给自己赋值，没有给属性（字段）赋值//this是当前对象的引用publicvoidshow(){System.out.println("我叫"+this.Myname+",今年"+this.age+"岁");}//记得也要加上this，这样会更加规范publicvoidfunc(){System.out.println("func1");}}publicclassTestDemo2{publicstaticvoidmain(String[] args){Student stu =newStudent();//定义一个对象
           stu.setMyname("deng");System.out.println(stu.getMyname());
         stu.show();}}//建议：将所有的属性（字段）设置为private，体现出封装

注意：

大驼峰：所有的单词的首字母都大写

小驼峰：除了第一个单词的首字母不大写，其余都大写

（class后面的就是类名）类名是大驼峰，其余都是小驼峰

自动补全打印字符串的方法 ( 代替上面的show方法)

光标放类里面，alt + insert就会出现toString ，选中即可

//方法：@Override//打印字符串内内容可以随便改publicStringtoString(){return"Student{"+"myName='"+ myName +'\''+", age="+ age +'}';}//主函数：System.out.println(stu);//直接传一个对象就行了

序列化：toString ：将对象转换成字符串

反序列化：将字符串转换为对象

构造方法

构造方法：它的方法名与类名是一样的，并且没有返回值

由于后面在main中实例化对象时要用到构造方法，所以现在构造方法先写成public

在对象实例化的时候就已经调用构造方法了

1.一个类一定至少存在一个构造方法，就算我不写构造方法，编译器也会自动帮我补一个没有参数的构造方法

2.要是我们自己写了构造方法，编译器就不会为我们生成不含参数的构造方法

首先快速写出代码（alt + insert 快速补全接口）

classPerson1{privateString name;privateint age;//*  以下 两个alt  +  insert 就解决了publicStringgetName(){return name;}publicvoidsetName(String name){this.name = name;}publicintgetAge(){return age;}publicvoidsetAge(int age){this.age = age;}@OverridepublicStringtoString(){return"我的名字叫"+
                 name  +", 我的年龄是"+ age
                ;}}//*publicclassTestDemo3{publicstaticvoidmain(String[] args){Person1 stu =newPerson1();//实例化对象
        stu.setName("deng");
        stu.setAge(10);System.out.println(stu);}}

实例化一个对象时，提出问题:一个对象的产生要几步?是如何产生的?

1.为对象分配内存空间

2.调用合适的构造方法

自动创建构造方法

alt+insert constructor 再选择要生成的构造方法

//构造方法名与类名一致，构造方法写在类里面publicPerson1(String name,int age){this.name = name;this.age = age;System.out.println("haha");}

在实例化一个对象的时候就会自动调用构造方法，所以就会打印出haha

关键字 this 代表对象，这句话对不对?要是不对，为什么不对？

要知道 this 是当前对象的引用

但是要解释原因的话，是因为如果this是对象的话，那么应该已经实现了调用构造方法，可是在创建构造方法的时候，又使用到了this，所以自相矛盾（反证法）

或者说调用构造方法完成之后才会有对象，可是在调用构造方法的时候用到了this ，所以矛盾

关键字 this

this( ): 根据传过来的参数，调用当前对象的其他的构造方法并且只能调用一次，只能存在于构造函数中
this.data:调用当前对象的属性
this.func() :调用当前对象的方法一定要习惯使用this （当前对象的引用）

在此强调：构造方法名与类名相同，并且构造方法没有返回值

//注意：构造方法非常简单，直接  alt + insert，选中constructor，选择想要的构造方法就行了classPerson1{privateString name;privateint age;publicStringgetName(){//这就是一个没有参数的构造方法return name;}//1.没有参数的构造方法publicPerson1(){//没有返回值，说明就是构造方法this("lihua",34);//这里就会自动去下面调用Person1(String name, int age)这个构造方法this("zhangfei");//err  在构造方法里面只能调用一次别的构造方法}//2.有两个参数的构造方法publicPerson1(String name,int age){this.name = name;this.age = age;System.out.println("haha");}//3.有一个参数的构造方法publicPerson1(String name){this.name = name;}//以上三个构造方法其实就是重载publicvoidsetName(String name){this.name = name;}publicintgetAge(){return age;}publicvoidsetAge(int age){this.age = age;}@OverridepublicStringtoString(){return"我的名字叫"+
                 name  +", 我的年龄是"+ age
                ;}}publicclassTestDemo3{publicstaticvoidmain(String[] args){Person1 stu =newPerson1("zhangsan",12);//实例化对象，在new 对象时，给构造方法传参
        stu.setName("deng");
        stu.setAge(10);System.out.println(stu);//进行打印}}

重载：

方法名称一样
参数列表不同（参数的数量，参数的类型）
返回值不作要求

构造方法支不支持重载？

由上面的代码已经证明了构造方法支持重载

//构造方法 publicPerson1(String name,int age){this.name = name;this.age = age;System.out.println("haha");}

支持，因为构造方法复合重载的要求

代码块

实例代码块（也叫构造代码块）
静态代码块
本地代码块（不会用到）//实例代码块{this.name ="likui";}publicstaticvoidfunc(){//静态方法System.out.println("haha");}//静态代码块static{//this.name = "刘备";//err name是实例成员变量，在静态里面只能用静态//静态的方法和静态的成员是不依赖于对象的，所以直接用类名来访问Person1.func();}``````classTrial{//实例代码块{System.out.println("实例代码块");}//静态代码块static{System.out.println("静态代码块");}publicTrial(){//没有返回值，说明是构造方法System.out.println("haha");}}publicclassTestDemo4{publicstaticvoidmain(String[] args){Trial want =newTrial();//实例化对象的过程中会调用先调用静态代码块，再是实例代码块，最后调用构造方法}}//打印结果为：//静态代码块//实例代码块//haha``````classTrial{//实例代码块{System.out.println("实例代码块");}//静态代码块static{System.out.println("静态代码块");}publicTrial(){System.out.println("haha");}}publicclassTestDemo4{publicstaticvoidmain(String[] args){Trial want1 =newTrial();System.out.println("=============================");Trial want2 =newTrial();}}//结果为：/*静态代码块实例代码块haha=============================实例代码块haha*/总结：静态的内容只会被执行一次，且是最早执行的，与定义的顺序无关静态成员变量 count 定义的顺序不同的区别：进行对比：classTrial{publicstaticint count =0;//实例代码块{System.out.println("实例代码块");}//静态代码块static{ count =20;//count是静态成员变量System.out.println("静态代码块");System.out.println(count);}publicTrial(){System.out.println("haha");}}publicclassTestDemo4{publicstaticvoidmain(String[] args){Trial want1 =newTrial();//System.out.println(Trial.count);}}/* 结果是：静态代码块20实例代码块haha*/``````classTrial{//静态代码块static{ count =20;System.out.println("静态代码块");//System.out.println(count); 修改1：此时还没定义count，不能使用count，因此在main里面打印}publicstaticint count =0;//实例代码块{System.out.println("实例代码块");}publicTrial(){System.out.println("haha");}}publicclassTestDemo4{publicstaticvoidmain(String[] args){Trial want1 =newTrial();System.out.println(Trial.count);//修改二：在main里面打印count}}/*此时结果就是静态代码块实例代码块haha0 */总结：要是都是静态的，就与定义的顺序有关，但是一般来说，都是将字段（成员变量）在前面的例外：

匿名对象

只调用一次，不创建具体的对象

classPerson{//类privateint  age=18;//字段/属性publicvoidfunc(){//成员方法System.out.println("eat");}}publicclass category {publicstaticvoidmain(String[] args){newPerson().func();//只调用一次方法//要用第二次，就要重新new，所以有匿名对象有很大的缺陷}

小练习

编写一个编写一个类Calculator ，有两个属性num1和num2这两个数据的值，不能在定义的同时初始化，最后实现1加减乘除四种运算

class calculator {privateint num1;privateint num2;publicintgetNum1(){return num1;}publicvoidsetNum1(int num1){this.num1 = num1;}publicintgetNum2(){return num2;}publicvoidsetNum2(int num2){this.num2 = num2;}publicintSum(){//不能加上static，要是加上static，这个方法就是静态的了，不依赖于对象，下面就不能使用num1和num2return num1 + num2;}publicintSub(){return num1 - num2;}publicintMul(){return num1 * num2;}publicdoubleDiv(){return num1 *1.0/ num2;}}publicclassTime{publicstaticvoidmain1(String[] args){//不能在类里面进行属性的初始化，就只能使用private封装，提供接口来进行初始化
        calculator calculator =newcalculator();
        calculator.setNum1(1);
        calculator.setNum2(2);System.out.println(calculator.Sum());}

实现交换两个变量的值，要求：需要交换实参的值

classMyvalue{//定义一个类publicint val;}publicclassTime{publicstaticvoidswap(Myvalue myvalue1,Myvalue myvalue2){int tmp = myvalue1.val;
        myvalue1.val = myvalue2.val;
        myvalue2.val =tmp;System.out.println(myvalue1.val+" "+ myvalue2.val);}publicstaticvoidmain(String[] args){Myvalue myvalue1 =newMyvalue();
        myvalue1.val =10;Myvalue myvalue2 =newMyvalue();
        myvalue2.val =20;swap(myvalue1,myvalue2);//传过去的是对象}}

标签： java 开发语言

本文转载自: https://blog.csdn.net/m0_60354608/article/details/124647748
版权归原作者 fiance111 所有，如有侵权，请联系我们删除。