类与对象
====================================================================================
1.类与对象的介绍与定义
- 类与对象是面向对象程序设计中的核心编程;
- 世间万物或具体或抽象;皆可对象;需要定义好对象的属性和行为;以此可以完成某件事;对象与引用介绍 跳转链接
- 类:类是自定义的数据类型,实例化出来的变量我们成为对象;类是用来对一些实体(对象)来进行描述的,主要描述该实体(对象)具有哪些属性(外观尺寸等),哪些功能(用来干啥);
- 使用class关键字来定义类:
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method(); // 行为 或者 成员方法
}
- 类名注意采用大驼峰定义
- 一个.java文件当中可以定义多个类,但必须有一个以public修饰的类;
- main方法所在的类必须要使用public修饰
- public修饰的类必须要和文件名相同
- new 关键字用于创建一个对象的实例.
- 使用 . 来访问对象中的属性和方法.
- 同一个类可以创建多个实例.
例:
// 在同一个包中创建的类,都可以被一个主类的主方法调用;(下例中,在Dog类中定义的该对象属性、行为;在ClassPractice类中主类的主函数中进行Dog对象实例化,进而初始化和调用方法)
package objectClass;
/**
* @Author: 19261
* @Date: 2021/9/3 17:07
*/
//通过创建特定的类,表示实际的对象特征;
public class Dog {
//属性
public String name; //属性1:名字
public int age; //属性2:年龄
public String breed;//属性3:品种
//方法/行为
public void eat(){
System.out.println(name+"正在吃饭!");
}
public void play(){
System.out.println(name+"正在玩耍!");
}
public void introduce(){
System.out.println(name+"是"+breed+"品种,"+"今年"+age+"岁了!");
}
}
package objectClass;
/**
* @Author: 19261
* @Date: 2021/9/1 19:34
*/
public class ClassPractice {
public static void main(String[] args) {
//对象实例化
//对象属性初始化:通过 . 解引用操作
//方法行为的调用:通过 . 调用该对象封装类的方法,完成某种行为
Dog dog1=new Dog();
dog1.name="小呆";
dog1.age=1;
dog1.breed="金毛";
Dog dog2=new Dog();
dog2.name="旺财";
dog2.age=2;
dog2.breed="吉娃娃";
Dog dog3=new Dog();
dog3.name="迪加";
dog3.age=1;
dog3.breed="边牧";
dog1.introduce();
dog2.introduce();
dog3.introduce();
dog1.eat();
dog2.play();
dog3.play();
}
}
2.类成员初始化
(1)默认初始化
// 默认初始化: 只要创建了类对象,Java中都会先把对象成员自动设置为默认值;
- 数字类型(包括整数和浮点数)默认值为0;
- 布尔类型默认为false;
- 引用类型默认为null;
public class Test {
public byte a;
public short b;
public char c;
public int d;
public long e;
public double f;
public boolean l;
public String s;
public int[] arr;
}
public class ClassPractice {
public static void main(String[] args) {
Test t=new Test();
System.out.println(t.a);
System.out.println(t.b);
System.out.println(t.c);
System.out.println(t.d);
System.out.println(t.e);
System.out.println(t.f);
System.out.println(t.l);
System.out.println(t.s);
System.out.println(t.arr);
}
}
(2)构造方法对类字段初始化
- 类对象的构造方法必须与类名相同;
- 若类中已经定义了有参构造方法,则不在生成无参构造的对象;
- 类中的构造方法没有return返回值,默认返回对象本身;
- 构造方法支持重载(通过参数个数和类型的不同实现重载)
- 构造方法不需要显式调用,在类对象通过new关键字创建时 自动调用执行;
class Student{
//成员/属性
public String name;
public int age;
//构造方法
public Student(){
name="小明";
age=18;
}
public Student(int a){
age=a;
}
public Student(String n){
name=n;
}
public Student(String n,int a){
name=n;
age=a;
}
public void show(){
System.out.println(name+" "+age);
}
}
public class ClassPractice {
public static void main(String[] args) {
//对象实例化
//对象属性初始化:通过 . 解引用操作
//方法行为的调用:通过 . 调用该对象封装类的方法,完成某种行为
Student s1=new Student();
s1.show();
Student s2=new Student("小红");
s2.show();
Student s3=new Student(2);
s3.show();
Student s4=new Student("小白",19);
s4.show();
}
}
// 创建对象时,通过 new() 调用实现自动调用构造方法初始化;
// 在创建对象时,先默认初始化;然后再通过构造方法初始化;没有通过构造方法初始化的成员属性,仍保留默认值;
(3)this 的使用与代码块初始化
- this 表示当前对象本身的引用;
- this 在成员方法中,只能只想该对象,不能再指向别的对象,具有final属性;
- 可以通过this 调用自身的构造方法;
- this 只能在成员方法中使用,必须放在第一行,第一个使用;
- 使用场景:当形参与成员名相同时,必须加以区分,使用this . 属性 ——表示指向对象本身;
- java编译器给每个“成员方法“增加了一个隐藏的引用类型参数,该引用参数指向当前对象(成员方法运行时调用该成员方法的对象),在成员方法中中所有成员变量的操作,都是通过该引用去访问。
// 代码块相当于无参的构造方法;并且构造方法后执行于代码块;
public class Point {
public int x;
public int y;
//相当于没有参数的构造方法,也是在new 创建对象时自动调用
{
x=0;
y=1;
}
//构造方法在默认初始化和代码块初始化之后执行的初始化
public Point(int x,int y){
//当形参和类成员属性名字相同时,使用Java中的this 指向对象的该属性
this.x=x;
// 通过this调用它自身构造方法
//this(x);
this.y=y;
}
public void show(){
System.out.println("点("+x+","+y+")");
}
}
public class ClassPractice {
public static void main(String[] args) {
Point p=new Point(1,2);
p.show();
}
}
- // 在IDEA 中可以自动生成构造方法:
Alt+Insert ->Constructor -> 选择属性 ->点击ok 完成创建;
3.类成员函数 toString的使用
- 每一个类中都可以创建一个toString()方法 用于查看所创建对象的属性;
- 调用自己创建的toString()方法:System.out.println(对象名)/ 对象名 . toString();
- IDEA 中可以自动生成toString()方法:Alt+Insert ->toString() -> 选择全部属性 ->点击ok 完成创建;
- 自动生成的toString()方法 使用的时候直接 利用输出语句调用System.out.println(对象名);
// public String toString(){
// return "点("+this.x+","+this.y+")";
// }
@Override
public String toString() {
return "Point{" +
"x=" + x +
", y=" + y +
'}';
}
5.包与全限定类名
- 包::为了更好的管理类,把多个类或者收集在一起成为一组,称为软件包。
- 包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,
- 在同一个工程中允许存在相同名称的类,只要处在不同的包中即可;
- // 自定义包 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包;
- 编写代码时,需要创建隶属于别的包(自定义/Java系统包)的对象,需要将类导入包中:
- 1.通过全限定类名创建:
java.util.Data data=new Data();
- 2.通过使用 import语句导入包.
import java.util.Data;
//import java.util.*;
表示导入Java类工具包util中的所有类;
- 1.通过全限定类名创建:
// 常见的Java包:
- java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
- java.lang.reflect:java 反射编程包;
- java.net:进行网络编程开发包。
- java.sql:进行数据库开发的支持包。
- java.util:是java提供的工具程序包。(集合类等) 非常重要
- java.io:I/O编程开发包。
6.static修饰与public、private修饰
(1)static的使用
- 在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的。
- static 的使用:
- 被static修饰的成员或属性,是类的属性/成员/字段,可以通过 对象.属性 访问,但一般通过 类名.属性访问;
- 类的成员的生命周期伴随类的一生(即:随类的加载而创建,随类的卸载而销毁)。JDK7及以前,HotSpot(Java虚拟机)中存储在方法区,JDK8及之后,类变量存储在Java堆中;
- 被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。静态成员一般是通过静态方法来访问的(类名 . 成员方法)。
- 静态方法没有隐藏的this引用参数,因此不能在静态方法中访问任何非静态成员变量
- 可以在非静态方法中调用静态成员方法;
- 被static修饰的成员或属性,是类的属性/成员/字段,可以通过 对象.属性 访问,但一般通过 类名.属性访问;
public class Computer{
public int id;
private static String cpu;
public String memory;
public Computer() {
id=123;
cpu="MAR";
memory="100G";
}
public void show(){
System.out.println(id);
//可以在非静态方法中调用静态成员方法
this.replace("MMM");
}
public static void replace(String s){
//this.id=n;
cpu=s;
System.out.println(cpu);
}
@Override
public String toString() {
return "Computer{" +
"id=" + id +
", memory='" + memory + '\'' +
", cpu='" + cpu + '\''+
'}';
}
}
public class ClassPractice {
public static void main(String[] args) {
Computer c=new Computer();
System.out.println(c);
c.show();
Computer.replace("max");
}
}
- 实例代码块与static代码块:
//实例代码块
{
this.id=333;
this.memory="50G";
this.cpu="MAR20";
System.out.println("执行实例代码块");
}
//static代码块
static{
cpu="NULL";
System.out.println("执行static代码块");
}
// 通过代码运行结果可知:
- 由static修饰的静态代码块不管生成多少个对象,其只会执行一次静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的;
(2)访问限定符
- Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制那些方法或者属性需要在类外直接使用;
- // 表格中有三角符号表示该限定符修饰的可以访问;
public:可以理解为一个人的外貌特征,谁都可以看得到
default: 对于自己家族中不是什么秘密,对于其他人来说就是隐私了
private:只有自己知道,其他人都不知道 - 访问权限除了可以限定类中成员的可见性,也可以控制类的可见性
例:
7.Java面向对象之 封装
- 面相对象程序三大特性:封装、继承、多态。而类和对象阶段,主要研究的就是封装特性。
- **封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。**控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护,也加强了程式码的安全性。
- 封装是一种信息隐藏技术,在java中通过关键字private,protected和public实现封装。