JavaSE——类和对象-创新互联
目录
一、万物皆对象
二、类的定义方式以及对象的实例化
1.类的定义方式
2.对象的实例化
三、类中的成员变量和成员方法的使用
1.static修饰成员变量
2.static修饰成员方法
四、对象的整个初始化过程
1. 初始化对象
2.构造方法
3.默认初始化
4.就地初始化
五、封装特性
访问限定符
六、代码块
1.普通代码块
2.构造代码块
3.静态代码块
七、内部类
1.成员内部类
1）普通内部类
2）静态内部类
2.局部内部类
一、万物皆对象
1. 在学习类和对象之前先了解一下面向对象的过程：
一图可解传统洗衣服都面向一个过程：拿水盆->倒水->放衣服->放洗衣粉->手搓->换水->放洗衣粉->手搓->拧干->晾衣服，少一个环节可能都不行
2.那么接下来关于面向对象洗衣服：
二、类的定义方式以及对象的实例化以面向对象方式来进行处理，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，导入洗衣粉，启动开关
类是用来对一个实体(对象)，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)
1.类的定义方式- class为定义类的关键字，ClassName为类的名字，{}中为类的主体
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}- 类中包含的内容称为类的成员，属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法
public class WashMachine {
public String brand;// 品牌
public String type;// 型号
public double weight;// 重量
public double lenght;// 长
public double weigth;// 宽
public double height;// 高
public String color;// 高
public void washClothes(){// 洗衣服
System.out.println("洗衣功能");
}
public void dryClothes(){// 脱水
System.out.println("脱水功能");
}
public void setTime(){// 定时
System.out.println("定时功能");
}
}- 小练习巩固定义类：
public class PetDog {
//定义一个狗类
public String name;//名字
public String color;//颜色
// 狗的属性
public void barks(){
System.out.println(name+"：汪汪汪~~~");
}
// 狗的行为
public void wag(){
System.out.println(name+"：摇尾巴~~~");
}
}
- 用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象
public class Main {
//实例化
public static void main(String[] args) {
PetDog dogh = new PetDog();//通过new实例化对象
dogh.name = "阿黄";
dogh.color = "黑黄";
dogh.barks();
dogh.wag();
PetDog dogs = new PetDog();
dogh.name = "阿黄";
dogh.color = "黑黄";
dogh.barks();
dogh.wag();
}
}
- this引用的是调用成员方法的对象
public class Date {
public int year;
public int month;
public int day;
public void setDay(int year,int month,int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year+"/"+this.month+"/"+this.day);
}
public static void main(String[] args) {
Date d = new Date();
d.setDay(2023,1,12);
d.printDate();
}
}三、类中的成员变量和成员方法的使用 1.static修饰成员变量【this引用的特性】
1. this的类型：对应类类型引用，哪个对象调用就是哪个对象的引用类型 2. this只能在 " 成员方法 " 中使用 3. 在 " 成员方法 " 中， this 只能引用当前对象，不能再引用其他对象 4. this是 “ 成员方法 ” 第一个隐藏的参数，编译器会自动传递
- static修饰的成员变量，称为静态成员变量
public class Student1{
public String name;
public String sex;
public int age;
public double score;
public static String classRoom = "Bit306";
public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问
System.out.println(Student1.classRoom);
Student1 s1 = new Student1("LiLeiLei","男",18,3.8);
Student1 s2 = new Student1("HanMeiMei","女",19,4.0);
Student1 s3 = new Student1("Jim","男",18,2.6);
// 也可以通过对象访问：但是classRoom是三个对象共享的
System.out.println(s1.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}
}2.static修饰成员方法【静态成员变量特性】
1. 不属于某个具体的对象，是类的属性，所有对象共享不存储在某个对象的空间中 2. 既可以通过对象访问，也可以通过类名访问 3. 类变量存储在方法区当中 4. 生命周期伴随类的一生 ( 随类的加载而创建，随类的卸载而销毁 )
- Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问
public class Student2 {
public String name;
public String gender;
public int age;
public double score;
public static String classRoom = "Bit306";
public static String getClassRoom(){
return classRoom;
}
public static void main(String[] args) {
System.out.println(Student2.classRoom);
}
}四、对象的整个初始化过程 1. 初始化对象【静态方法特性】
1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用
3. 静态方法没有隐藏的this引用参数
4. 静态方法中不能调用任何非静态方法
- 需要调用之前写的SetDate方法才可以将具体的日期设置到对象中
- 构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次
public class Date {
public int year;
public int month;
public int day;
// 构造方法：
// 名字与类名相同，没有返回值类型，设置为void也不行
// 一般情况下使用public修饰
// 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
public Date(int year,int month,int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year+"/"+this.month+"/"+this.day);
}
public static void main(String[] args) {
// 此处创建了一个Date类型的对象，并没有显式调用构造方法
Date d = new Date(2023,1,12);// 输出Date(int,int,int)方法被调用了
d.printDate();//2023/1/12
}
}3.默认初始化【构造方法特性 】
1. 名字必须与类名相同 2. 没有返回值类型，设置为 void 也不行 3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次 4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 )public class Date1 { public int year; public int month; public int day; //无参构造方法 public Date1() { this.year = 2023; this.month = 1; this.day = 12; } //带有三个参数的构造方法 public Date1(int year, int month, int day) { this.year = year; this.month = month; this.day = day; } public void printDate(){ System.out.println(year+"-"+month+"-"+day); } public static void main(String[] args) { Date1 d = new Date1(); d.printDate(); } }
- 名字相同，参数列表不同构成了方法重载
5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定无参
public class Snakek {
private int age;
public static void main(String[] args) {
Snakek snakek = new Snakek();
System.out.println(snakek.age);//0
}
}- 要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情
4.就地初始化在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单了解：
1. 检测对象对应的类是否加载了，如果没有加载则加载 2. 为对象分配内存空间 3. 处理并发安全问题 4. 初始化所分配的空间
- 在声明成员变量时，就直接给出了初始值
public class Date2 {
public int year = 2023;
public int month = 1;
public int day = 12;
public Date2() {
}
public Date2(int year, int month, int day) {
}
public static void main(String[] args) {
Date2 d1 = new Date2(2023,1,12);
Date2 d2 = new Date2();
}
}封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互
访问限定符
public ：可以理解为一个人的外貌特征，谁都可以看得到 default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密，对于其他人来说就是隐私了 private ：只有自己知道，其他人都不知道
public class Computer {
private String cpu;//cpu
private String memory;//内存
public String screen;//屏幕
String brand;// 品牌---->default属性
public Computer(String cpu, String memory, String screen, String brand) {
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
this.brand = brand;
}
public void Boot(){
System.out.println("开机~~~");
}
public void PowerOff(){
System.out.println("关机~~~");
}
public void SurfInternet(){
System.out.println("上网~~~");
}
}
public class TestComputer {
public static void main(String[] args) {
Computer p = new Computer("HW","17","8G","13*14");
System.out.println(p.brand);// default属性：只能被本包中类访问
System.out.println(p.screen);// public属性： 可以任何其他类访问
//System.out.println(p.cpu);// private属性：只能在Computer类中访问，不能被其他类访问
}
}- 一般情况下成员变量设置为private，成员方法设置为public
1.普通代码块使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字可分为以下四种 ：普通代码块 、构造块 、静态块 、同步代码块（后续讲解多线程部分再谈）
- 普通代码块：定义在方法中的代码块
public class Main {
public static void main(String[] args) {
{ //直接使用{}定义，普通方法块
int x = 10;
System.out.println("x1 = "+x);//x1 = 10
}
int x = 100;
System.out.println("x2 = "+x);//x2 = 100
}
}- 构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量
public class Student {
//实例成员变量
private String name;
private String sex;
private int age;
private double score;
public Student() {
System.out.println("l am Student in it ()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Person p1 = new Person();
p1.show();
}
}- 使用static定义的代码块称为静态代码块，一般用于初始化静态成员变量
public class Student1 {
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例化代码块
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
//静态代码块
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student1() {
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student1 s1 = new Student1();
Student1 s2 = new Student1();
}
}七、内部类【注意事项】
1.静态代码块不管生成多少个对象，其只会执行一次
2.静态成员变量是类的属性
3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成的方法中，该方法在类加载时调用，并且只调用一次
4.实例代码块只有在创建对象时才会执行
- 在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现
1）普通内部类在外部类中，内部类定义位置与外部类成员所处的位置相同
- 未被static修饰的成员内部类
public class OutClass1 {
private int a;
static int b;
int c;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 成员内部类：未被static修饰
class InnerClass{
int c;
public void methodInner(){
// 在内部类中可以直接访问外部类中：任意访问限定符修饰的成员
a = 100;
b = 200;
methodA();
methodB();
// 如果外部类和内部类中具有相同名称成员时，优先访问的是内部类自己的
c = 300;
System.out.println(c);
// 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
OutClass1.this.c = 400;
System.out.println(c);
}
}
public static void main(String[] args) {
// 外部类：对象创建 以及 成员访问
OutClass1 outClass1 = new OutClass1();
System.out.println(outClass1.a);
System.out.println(outClass1.b);
System.out.println(outClass1.c);
outClass1.methodA();
outClass1.methodB();
System.out.println("=============内部类的访问=============");
// 创建内部类对象
InnerClass innerClass = new OutClass1().new InnerClass();
// 先将外部类对象先创建出来，然后再创建内部类对象
InnerClass innerClass2 = outClass1.new InnerClass();
innerClass2.methodInner();
}
}【 注意事项 】 1. 外部类中的任何成员都可以被在普通内部类方法中直接访问 2. 在内部类方法中访问同名的成员时，优先访问自己的 3. 普通内部类对象必须在先有外部类对象前提下才能创建 4. 外部类中，不能直接访问内部类中的成员，如果要访问必须先要创建外部类的对象2）静态内部类
- 被static修饰的内部成员类称为静态内部类
public class OutClass2 {
private int a;
static int b;
public void methodA(){
a = 10;
System.out.println(a);
}
public static void methodB(){
System.out.println(b);
}
// 静态内部类：被static修饰的成员内部类
static class InnerClass{
public void methodInner(){
// 在内部类中只能访问外部类的静态成员
//a = 100; // 编译失败，因为a不是类成员变量
b = 200;
//methodA(); // 编译失败，因为methodB()不是类成员方法
methodB();
}
}
public static void main(String[] args) {
// 静态内部类对象创建 & 成员访问
InnerClass innerClass = new InnerClass();
innerClass.methodInner();
}
}【 注意事项 】 1. 在内部类中只能访问外部类中的静态成员 2. 创建内部类对象时，不需要先创建外部类对象2.局部内部类
- 定义在外部类的方法体或者{}中
public class OutClass3 {
int a = 10;
public void method(){
int b = 10;
// 局部内部类：定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用，其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
//OutClass2.InnerClass innerClass = null;编译失败
}
}【 注意事项 】 1. 局部内部类只能在所定义的方法体内部使用 2. 不能被 public 、 static 等修饰符修饰与君共勉：时间最不偏私，给任何人都是二十四小时；时间也最偏私，给任何人都不是二十四小时
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
网站标题：JavaSE——类和对象-创新互联
转载源于：http://pwwzsj.com/article/disiph.html
