• Java学习 10.Java-类和对象

    一、面向对象的初步认知

    1.1 什么是面向对象

    面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情，用面向对象的思想来设计程序，更符合人们对事物的认知，对于大型程序的设计、拓展以及维护都非常友好

    1.2 面向对象与面向过程

    面向对象只看最终结果，面向过程面对对象操作

    二、类的定义和使用

    2.1 简单认识类

    类——描述一个对象

    定义在类中的变量叫做成员变量，定义在类中的方法叫做成员方法，类是产生对象的一种抽象过程

    2.2 类的定义格式

    类 == 结构体 通过class自定义的类型

    2.3 案例

    定义一个狗类

    一个Java文件只能有一个public修饰的类

    代码实现

    1. class Dog{
    2.     public String name;
    3.     public String color;
    4.     public int age;
    5.     //行为
    6.     public void barks(){
    7.         System.out.println(name+": 旺旺旺~~~");
    8.     }
    9.     public void wag(){
    10.         System.out.println(name+"：摇尾巴~~~");
    11.     }
    12. }

    定义一个学生类

    代码实现

    1. //定义一个学生类
    2. public class Student {
    3.     public String name;
    4.     public String gender;
    5.     public short age;
    6.     public double score;
    7.     public void DoClass(){}
    8.     public void DoHomework(){}
    9.     public void Exam(){}
    10. }

    注意事项

    1.一般一个文件当中只定义一个类

    2.main方法所在的类一般要使用public修饰（注意：Eclipse默认会在public修饰的类中找main方法）

    3.public修饰的类必须要和文件名相同 一个Java文件只能有一个public修饰的类

    4.不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改，Java文件当中只有一个类修改文件名，然后自动修改类名，若有多个类，修改类名，右键点击类，点击Refacter，点击Rename

    三、类的实例化

    类定义好后，由类转化为对象的过程叫做实例化

    3.1 什么是实例化

    将类实例化约等于定义一个结构体变量，通过关键字new实例化

    由类产生对象的过程

    new关键字配合类名创建对象

    1.     Dog dog1 = new Dog();
    2.     Dog dog2 = new Dog();
    3.     Dog dog3 = new Dog();

    注意事项

     通过引用可以拿到类中具体对象

    语法：对象的引用.访问属性 进行赋值

    只要new 就会产生新的对象 只要是新的对象，就有新的内存，只要通过对象的引用，去访问对象的成员变量即可或者是成员方法

    我们可以通过new关键字实例化多个对象，同一个类可以产生多个实例

    1.         public static void main(String[] args) {
    2.         Dog dog1 = new Dog();
    3.         dog1.name = "阿黄";
    4.         dog1.age = 4;
    5.         dog1.color = "黄";
    6.         System.out.println("年龄 "+dog1.age);
    7.         System.out.println("姓名 "+dog1.name);
    8.         System.out.println("颜色 "+dog1.color);
    9.         dog1.barks();
    10.         dog1.wag();
    11.         Dog dog2 = new Dog();
    12.         dog2.name="旺财";
    13.         dog2.color="白";
    14.         dog2.age=6;
    15.         System.out.println("年龄 "+dog2.age);
    16.         System.out.println("姓名 "+dog2.name);
    17.         System.out.println("颜色 "+dog2.color);
    18.         dog2.barks();
    19.         dog2.wag();
    20.         Dog dog3 = new Dog();
    21.         Dog dog4 = new Dog();
    22.         }

    3.2 类和对象的说明 

    用类创建的对象都属于引用类型

    数据类型：

    1.基本数据类型，共8种

    2.引用数据类型，String、数组、类、接口，引用类型定义的变量都是用来存对象的地址

    注意：

    1.引用不能指向引用，引用只能指向对象

    2.一个引用同时只能指向一个对象，存储一个对象的地址

    3.引用对象=null，不代表指向null对象，代表不指向任何对象

    交换两个对象的值

    1. class Myvalue{
    2.     public int val;
    3. }   
    4.  
    5. public static void swap(Myvalue val1,Myvalue val2){
    6.     int tmp= val1.val;
    7.     val1.val= val2.val;
    8.     val2.val= tmp;
    9. }
    10.         Myvalue myvalue1=new Myvalue();
    11.         myvalue1.val=10;
    12.         Myvalue myvalue2=new Myvalue();
    13.         myvalue2.val=20;
    14.  
    15.         System.out.println("交换前 "+myvalue1.val);
    16.         System.out.println("交换前 "+myvalue2.val);
    17.  
    18.         swap(myvalue1,myvalue2);
    19.  
    20.         System.out.println("交换后 "+myvalue1.val);
    21.         System.out.println("交换后 "+myvalue2.val);

    通过类加对象进行交换两个引用数据类型的值

    基本类型无法进行两个数的交换，而引用类型通过类和对象的知识对两个数进行交换

    赋值案例

    1. public class example1 {
    2.     //时间类
    3.         public int year;
    4.         public int month;
    5.         public int day;
    6.  
    7.         public void setDate(int y,int m,int d){
    8.             year=y;
    9.             month=m;
    10.             day=d;
    11.         }
    12.  
    13.         public void printDate(){
    14.             System.out.println("年："+year+"月："+month+"日:"+day);
    15.         }
    16.  
    17.         public static void main(String[] args) {
    18.             Date date=new Date();
    19.             date.setDate(1945,9,1);
    20.             date.printDate();
    21.         }
    22.     }
    23.

    四、this引用

    4.1.为什么要有this引用

    1.形参名不小心与成员变量名相同

    2.多个对象都在调用一个函数，但是函数内部没有任何有关对象的说明

    4.2 什么是this引用

    this引用指向当前对象（成员方法运行时调用该成员方法的对象），在成员方法中所有成员变量的操作，都是通过该引用取访问

    注意：this引用的是调用成员方法的对象

    4.3 this引用的特性

    代码实现

    1. public class Date {
    2.     public int year;
    3.     public int month;
    4.     public int day;
    5.     public void setDate(int year,int month,int day){
    6.         //谁调用当前这个方法，谁就是this指向的对象
    7.         //我们建议习惯使用this
    8.         this.year=year;
    9.         this.month=month;
    10.         this.day=day;
    11.     }
    12.  
    13.     public void printDate(){
    14.         System.out.println(year+" 年 "+month+" 月  "+ day+" 日");
    15.         this.haha();
    16.     }
    17.  
    18.     public void haha(){
    19.         System.out.println("haha");
    20.     }
    21.  
    22.     public static void main(String[] args) {
    23.         Date date=new Date();
    24.         date.setDate(1945,9,1);
    25.         date.printDate();
    26.  
    27.  
    28.         Date date2=new Date();
    29.         date.setDate(1949,10,1);
    30.         date.printDate();
    31.     }
    32. }

    运行结果

    注意：同一级目录（src）下，类名不可重复

    五、对象的构造及初始化

    对象——由类产生的实体

    5.1 如何初始化对象

    只有局部变量没有初始化的时候才会报错

    5.2 默认初始化

    所有的引用类型初始化都是null

    就地初始化

    在创建变量时同时给他赋值，在后续使用变量时，如果没有给他赋值，则传递一开始创建变量时给他的值作为所有变量的初始值

    5.3 构造方法

    构造方法（构造器）是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次，构造方法没有返回值，方法名和类名相同

    构造方法的作用

    对对象中的成员进行初始化，并不负责给对象开辟空间

    构造方法至少有一个，也就是说当你没有写任何的构造方法的时候，编译器/Java会自带一个不带参数的构造方法，只不过默认的这个构造方法没有具体的实现

    构造方法的特点

    1.构造方法：特殊的方法，没有返回值，方法名和类名相同

    2.对象的初始化必定会调用构造方法

    3.构造方法不止一个，实例化一个对象，会调用合适的构造方法

    4.构造方法必定会被调用，构造方法可以重载，一旦用户定义了构造方法，编译器不在生成，如果有构造方法，编译器不会给你提供不带参数的构造方法

    5.this（...）必须是构造方法中的第一条语句

    6.绝大部分构造方法用public定义，特殊场景用private初始化会报错

    7.不能形成环，可以根据this来调用其他构造方法以简化代码，但不能调用循环 

    构造方法快捷键

    Generate-->constructor
    构造方法中可以用this.调用其他构造方法，节约代码量

    5.4 案例 Data类

    代码实现

    1. public class Date {
    2.     public int year;
    3.     public int month;
    4.     public int day;
    5.     boolean flg;
    6.     char e;
    7.     public void setDate(int year,int month,int day){
    8.         //谁调用当前这个方法，谁就是this指向的对象
    9.         //我们建议习惯使用this
    10.         this.year=year;
    11.         this.month=month;
    12.         this.day=day;
    13.     }
    14.  
    15.     public Date(int year,int month,int day){
    16.         this.year=year;
    17.         this.month=month;
    18.         this.day=day;
    19.     }
    20.     public Date(){
    21.         /*this.year=2002;
    22.         this.month=11;
    23.         this.day=4;*/
    24.         this(2002,11,04);//用this传递构造方法时，必须放在方法内部第一行
    25.         //不能形成环 绝大部分构造方法用public定义，特殊场景用private初始化会报错
    26.         System.out.println("执行了不带参数的构造方法......");
    27.     }
    28.     public void printDate(){
    29.         System.out.println(year+" 年 "+month+" 月  "+ day+" 日");
    30.         //this.haha();
    31.     }
    32.  
    33.     public void haha(){
    34.         System.out.println("haha");
    35.     }
    36.  
    37.     public static void main(String[] args) {
    38.         Date date=new Date();
    39.         //不带参数的构造方法，系统设置初值
    40.         System.out.println(date.day);//4
    41.         System.out.println(date.month);//11
    42.         System.out.println(date.year);//2002
    43.         System.out.println(date.e);//空字符
    44.         System.out.println(date.flg);//false
    45.         System.out.println();
    46.         //默认值2002年11月4日
    47.         date.printDate();
    48.         //setdate赋值构造方法
    49.         date.setDate(1945,9,1);
    50.         date.printDate();
    51.         System.out.println();
    52.         //不带参数的构造方法
    53.         Date date2=new Date();
    54.         //setdate赋值构造方法
    55.         date.setDate(1949,10,1);
    56.         date.printDate();
    57.         System.out.println();
    58.         //赋予三个初值的date方法
    59.         Date date3=new Date(1995,11,18);
    60.         date3.printDate();
    61.  
    62.         //构造方法快捷键
    63.         //Generate-->constructor
    64.         //构造方法中可以用this调用其他构造方法
    65.     }
    66. }
    67.

    运行结果

    总结

    六、封装 private

    加上private，代表这个方法只能在当前类中使用

    面向对象的几个重要的特征：封装、继承、多态

    Java、C++

    6.1.封装的概念

    封装：套壳屏蔽细节

    封装：屏蔽类的实现细节，对外只提供一些开放的接口

    为何要封装？安全考虑，更能体现类的安全性，提升安全性

    构造方法也可以被封装，封装后只能在当前类中使用

    案例

    name是private修饰，所以只能在当前类中使用

    1. class Student1{
    2.     //当private修饰当前变量时，当前变量只能在当前类中使用
    3.     private String name;
    4.     //实现封装后，类外无法直接拿到字段但是可以通过一些方法
    5.     public int age;
    6.  
    7.     //构造方法 也可以被封装 封装后方法只能在当前类中使用
    8.     public Student1(String name,int age){
    9.         this.name=name;
    10.         this.age=age;
    11.     }
    12.  
    13.     public void setName(String name){
    14.         this.name=name;
    15.     }
    16.  
    17.     public String getName(){
    18.         return this.name;
    19.     }
    20.  
    21.     public void setAge(int age) {
    22.         this.age = age;
    23.     }
    24.  
    25.     public int getAge() {
    26.         return age;
    27.     }
    28.  
    29.     public void eat(){
    30.         System.out.println(this.name+"正在吃饭！");
    31.     }
    32. }
    33. //封装是对类的实现细节进行隐藏，类外无法使用封装细节
    34.  
    35. public class day_14 {
    36.     public static void main(String[] args) {
    37.         Student1 student=new Student1("张三",10);
    38.          //private实现封装情况，在封装后，当前方法只能在当前类中使用
    39.         //封装 隐藏eat方法
    40.         student.setName("小王");
    41.         System.out.println(student.getName());
    42.         student.eat();
    43.     }
    44. }

    主要使用private对于类中的变量及方法进行限制，使得类中的方法和变量被限制后无法在类之外使用，大大提升了程序的安全性

    6.2 访问修饰限定符

    1.public 公开的 在哪里都能被访问到

    2.protected 受保护的 

    3.default 没有default这个权限，代表默认情况下，什么都不写

    4.private 私人的 只能在当前类中使用

    说明

    6.3 封装拓展之包

    6.3.1 包的概念

    为了更好地管理类，把多个类收集在一起成为一组，称为软件包，多个类放在一起称为一个包

    package 包名.包名. ...所有的包名中

    6.3.2 自定义包

    package+包名

    6.3.3 导入包中的类

    可以使用java.包名.类名，导入util这个包中的Date类，使用import语句直接导入包

    ALT+enter 快捷键显示存在哪个包中

    import java.包名.* ;通配，要用哪个包就直接导入哪个包

    可以用import static导入包中静态的方法和字段

    static修饰的方法可以直接用方法名调用

    包≈文件夹，类≈文件

    6.3.4 包的访问权限控制

    6.3.5 常见的包

    一般常见的包会由Java自动导入

    七.static成员关键字 

    静态成员

    7.1 static修饰静态成员变量特性

    1.不属于某个具体的对象，是类的属性，所有对象共享，不存储在某个对象的空间中

    2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

    3.类变量存储在方法区当中

    4.生命周期伴随类的一生（即：随类的加载而创建，随类的卸载而销毁）

    静态成员变量≈在当前类中使用的全局变量，静态的只能是成员变量，不能是局部变量

    7.2 static修饰方法

    在静态方法内部，不能使用非静态的数据成员

    this不能出现在静态方法内部当中

    静态方法特性

    4.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

    5.静态方法无法重写，不能用来实现多态

    总结

    静态变量也称为类变量，在类的对象之间通用，并且也可以使用类名来访问此变量

    非静态变量又称实例变量

    1.静态成员函数不能访问非静态变量

    2.非静态变量特定于创建它们的实例对象

    3.非静态变量可能会占有更多空间，内存分配可能在运行时发生

    4.普通变量不需要具有任何特殊的关键字

    静态的成员变量与非静态的成员变量的区别：

    1. 作用上的区别：

    1. 静态的成员变量的作用共享一个 数据给所有的对象使用。.

    非静态的成员变量的作用是描述一类事物的公共属性。

    2. 数量与存储位置上的区别：

    1. 静态成员变量是存储方法 区内存中，而且只会存在一份数据。\非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。

    3. 生命周期的区别：

    1. 静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。

    2.非静态的成员数据是随着对象的创建而存在，随着 对象被垃圾回收器回收而消失。

    八、代码块

    8.1 代码块概念以及分类

    使用{}定义的一段代码称为代码块有根据定义位置及关键字分为

    1.普通代码块

    2.构造代码块

    3.静态代码块

    4.同步代码块

    8.2 普通代码块

    {   },定义在方法当中的代码块，执行不需要条件，永远会被执行

    8.3 构造代码块

    定义在方法外部类内部

    叫做构造代码块或实例代码块

    一般用来初始化非静态的数据成员

    8.4 静态代码块

    static修饰的代码块，一般用于初始化静态成员变量

    初始化静态成员变量

    静态代码块一定最先被执行，其次是实例代码块，静态代码块不依赖对象

    如果都是静态的，则观察定义的顺序来决定执行的顺序

    注意事项

    1、静态代码块不管生成多少个对象，其都只会执行一次

    2.静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

    3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行（合并）

    4.实例代码块只有在创建对象时才会执行

    过一内容

    1. package com.bit.www.Test;
    2.  
    3. class DogP{
    4.     private String name;
    5.     private int age;
    6.     private String color;
    7.  
    8.     //构造方法，用来实例化
    9.  
    10.     public DogP(String name,int age,String color){
    11.         this.name=name;
    12.         this.age=age;
    13.         this.color=color;
    14.     }
    15.  
    16.     public String getName() {
    17.         return name;
    18.     }
    19.  
    20.     public void setName(String name) {
    21.         this.name = name;
    22.     }
    23.  
    24.     public int getAge() {
    25.         return age;
    26.     }
    27.  
    28.     public void setAge(int age) {
    29.         this.age = age;
    30.     }
    31.  
    32.     public String getColor() {
    33.         return color;
    34.     }
    35.  
    36.     public void setColor(String color) {
    37.         this.color = color;
    38.     }
    39.  
    40.     public void barks(){
    41.         System.out.println(this.name+"正在汪汪叫");
    42.     }
    43.  
    44.     public void eat(){
    45.         System.out.println(this.name+"正在吃狗粮");
    46.     }
    47.  
    48.     public void staticFun(){
    49.         System.out.println("staticFun......");
    50.     }
    51.  
    52.     public void show(){
    53.         System.out.println("狗名："+this.name+"年龄:"+this.age+"颜色"+this.color);
    54.     }
    55. }
    56. public class ts {
    57.         public static void main(String[] args) {
    58.             DogP dog=new DogP("旺财",3,"白色");
    59.             dog.setAge(4);
    60.             dog.setColor("黄色");
    61.             dog.eat();
    62.             dog.barks();
    63.  
    64.             //com.bit.www.Test.DogP@1554909b类型所在的地址
    65.             System.out.println(dog);
    66.             dog.show();
    67.         }
    68. }

  • 相关阅读:
    Grub启动Linux引导到BIOS问题的解决
    单点登录和分布式登入用户状态储存
    华为OD机考算法题：矩阵最大值
    泛型编程与模板
    二十、MySQL多表关系
    元素显示和背景调试
    记录Windows下mysql更改my.ini文件中datadir路径后启动不起来的问题
    基于conda的OpenCV库安装
    「运维有小邓」活动目录变更监控
    数据库的三种日志：redo log、binlog和undo log
  • 原文地址：https://blog.csdn.net/m0_73983707/article/details/134353224