哈尔滨市建设安全网站,扬州seo招聘,国外代理ip地址和端口,网站推广的特点文章目录 面向对象的初步认知类的实例化this引用对象的构造及初始化封装static成员代码块内部类 对象的打印一、面向对象的初步认知 Java是一门纯面向对象的语言(Object Oriented Program#xff0c;简称OOP)#xff0c;在面向对象的世界里#xff0c;一切皆为对象。在java中… 文章目录 面向对象的初步认知 类的实例化 this引用 对象的构造及初始化 封装 static成员 代码块 内部类 对象的打印 一、面向对象的初步认知
Java是一门纯面向对象的语言(Object Oriented Program简称OOP)在面向对象的世界里一切皆为对象。在java中定义类时需要用到class关键字具体语法如下 // 创建类 class ClassName{ fifield; // 字段(属性) 或者 成员变量 method; // 行为 或者 成员方法 } class为定义类的关键字ClassName为类的名字{}中为类的主体。 类中包含的内容称为类的成员。属性主要是用来描述类的称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能称为类的成员方法 注意 1. 一般一个文件当中只定义一个类 2. main方法所在的类一般要使用public修饰(注意Eclipse默认会在public修饰的类中找main方法) 3. public修饰的类必须要和文件名相同 4. 不要轻易去修改public修饰的类的名称如果要修改通过开发工具修改。 二、类的实例化
定义了一个类就相当于在计算机中定义了一种新的类型与intdouble类似只不过int和double是java语言自带的内置类型而类是用户自定义了一个新的类型用类类型创建对象的过程称为类的实例化在java中采用new关键字配合类名来实例化对象。 注意1、new 关键字用于创建一个对象的实例. 2、使用 . 来访问对象中的属性和方法. 3、同一个类可以创建对个实例. 4、当成员变量没有初始化的时候默认值就是对应的初始值。 class PetDog{public String name;public String color;public void barks(){System.out.println(汪汪汪--);}public void wag(){System.out.println(摇尾巴--);}
}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();dogs.name 阿黄;dogs.color 黑黄;dogs.barks();dogs.wag();}
} 三、this引用 this引用指向当前对象(成员方法运行时调用该成员方法的对象)在成员方法中所有成员变量的操作都是通过该引用去访问。只不过所有的操作对用户是透明的即用户不需要来传递编译器自动完成。 public class TestData{public int year;public int month;public int day;public void setDate(int year,int month,int day){this.yearyear;this.monthmonth;this.dayday;}public void printDate(){System.out.println(year-month-day);}public static void main(String[] args) {TestData testDatenew TestData();testDate.setDate(2023,2,27);/*testDate.year2023;testDate.month2;testDate.day27;*/testDate.printDate();}
} 注意this引用的是调用成员方法的对象。 this引用的特性 1. this的类型对应类类型引用即哪个对象调用就是哪个对象的引用类型。 2. this只能在成员方法中使用 。 3. 在成员方法中this只能引用当前对象不能再引用其他对象。 4.this是“成员方法”第一个隐藏的参数编译器会自动传递在成员方法执行时编译器会负责将调用成员方法对象的引用传递给该成员方法this负责来接收 。 四、对象的构造及初始化 在Java方法内部定义一个局部变量时必须要初始化否则会编译失败。 public class Main{public static void main(String[] args) {int a;System.out.println(a);}
} 对象初始化 class TestData{public int year;public int month;public int day;public void setDate(int year,int month,int day){this.yearyear;this.monthmonth;this.dayday;}public void printDate(){System.out.println(year-month-day);}public static void main(String[] args) {TestData testDatenew TestData();testDate.setDate(2023,2,27);/*testDate.year2023;testDate.month2;testDate.day27;*/testDate.printDate();}
}public class Main{public static void main(String[] args) {TestData datanew TestData();data.setDate(2023,3,3);data.printDate();}
} 构造方法 构造方法(也称为构造器)是一个特殊的成员方法名字必须与类名相同在创建对象时由编译器自动调用并且在整个对象的生命周期内只调用一次。 1. 名字必须与类名相同 2. 没有返回值类型设置为void也不行 3. 创建对象时由编译器自动调用并且在对象的生命周期内只调用一次(相当于人的出生每个人只能出生一次) 4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法) 名字相同参数列表不同因此构成了方法重载。 5.如果用户没有显式定义编译器会生成一份默认的构造方法生成的默认构造方法一定是无参的。 6.构造方法中可以通过this调用其他构造方法来简化代码 7. 绝大多数情况下使用public来修饰特殊场景下会被private修饰 class Date {public int year;public int month;public int day;public Date(int year, int month, int day){this.year year;this.month month;this.day day;System.out.println(Date(int,int,int)方法被调用了);}public void printDate() {System.out.println(year - month - day);}
}public class Main{public static void main(String[] args) {// 此处创建了一个Date类型的对象并没有显式调用构造方法Date d new Date(2023,3,3); d.printDate(); // }
} 注意构造方法的作用就是对对象中的成员进行初始化并不负责给对象开辟空间。 this(...)必须是构造方法中第一条语句 不能形成环 public Date(){ this(1900,1,1); } public Date(int year, int month, int day) { this(); } /* 无参构造器调用三个参数的构造器而三个参数构造器有调用无参的构造器形成构造器的递归调用 编译报错Error:(19, 12) java: 递归构造器调用 */ public class Date {public int year;public int month;public int day;// 无参构造方法--内部给各个成员赋值初始值该部分功能与三个参数的构造方法重复// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法// 但是this(1900,1,1);必须是构造方法中第一条语句public Date(){//System.out.println(year); 注释取消掉编译会失败this(1900, 1, 1);//this.year 1900;//this.month 1;//this.day 1;}// 带有三个参数的构造方法public Date(int year, int month, int day) {this.year year;this.month month;this.day day;
}
} 默认初始化 public class Date {public int year;public int month;public int day;public Date(int year, int month, int day) {// 成员变量在定义时并没有给初始值, 为什么就可以使用呢System.out.println(this.year);System.out.println(this.month);System.out.println(this.day);}public static void main(String[] args) {// 此处a没有初始化编译时报错// Error:(24, 28) java: 可能尚未初始化变量a// int a;// System.out.println(a);Date d new Date(2021,6,9);}
} 数据类型 默认值 byte 0 char \u0000 short 0 int 0 long 0L boolean false float 0.0f double 0.0 reference null 就地初始化 public class Date {public int year 1900;public int month 1;public int day 1;public Date(){}public Date(int year, int month, int day) {}public static void main(String[] args) {Date d1 new Date(2021,6,9);Date d2 new Date();}
} 五、封装 面向对象程序三大特性封装、继承、多态。 访问限定符 Java中主要通过类和访问权限来实现封装类可以将数据以及封装数据的方法结合在一起更符合人类对事物的认知而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符 class Computer {private String cpu; // cpuprivate String memory; // 内存public String screen; // 屏幕String brand; // 品牌----default属性public Computer(String brand, String cpu, String memory, String screen) {this.brand brand;this.cpu cpu;this.memory memory;this.screen screen;}public void Boot(){System.out.println(开机~~~);}public void PowerOff(){System.out.println(关机~~~);}public void SurfInternet(){System.out.println(上网~~~);}
}
public class Main {public static void main(String[] args) {Computer p new Computer(HW, i7, 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、在文件的最上方加上一个 package 语句指定该代码在哪个包中. 2、包名需要尽量指定成唯一的名字。例如com.bit.demo1 ). 3、包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码. 4、如果一个类没有 package 语句, 则该类被放到一个默认包中. 操作步骤 1. 在 IDEA 中先新建一个包: 右键 src - 新建 - 包 2. 在弹出的对话框中输入包名, 例如 com.bit.demo1 3. 在包中创建类, 右键包名 - 新建 - 类, 然后输入类名即可. 4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了 5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句 Java中常见的包 1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。 2. java.lang.reflflect:java 反射编程包; 3. java.net:进行网络编程开发包。 4. java.sql:进行数据库开发的支持包。 5. java.util:是java提供的工具程序包。(集合类等) 非常重要 6. java.io:I/O编程开发包。 六、static成员 static修饰的成员变量称为静态成员变量静态成员变量最大的特性不属于某个具体的对象是所有对象所共享的。 【静态成员变量特性】 1. 不属于某个具体的对象是类的属性所有对象共享的不存储在某个对象的空间中 2. 既可以通过对象访问也可以通过类名访问但一般更推荐使用类名访问 3. 类变量存储在方法区当中 4. 生命周期伴随类的一生(即随类的加载而创建随类的卸载而销毁) public class Student {public String name;public String gender;public int age;public double score;public static String classRoom Bit306;// ...public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问System.out.println(Student.classRoom);Student s1 new Student(Li leilei, 男, 18, 3.8);Student s2 new Student(Han MeiMei, 女, 19, 4.0);Student s3 new Student(Jim, 男, 18, 2.6);
// 也可以通过对象访问但是classRoom是三个对象共享的System.out.println(s1.classRoom);System.out.println(s2.classRoom);System.out.println(s3.classRoom);}
} 一般类中的数据成员都设置为private而成员方法设置为public。 class Student{private String name;private String gender;private int age;private double score;private static String classRoom Bit306;
// ...
}
public class Main {public static void main(String[] args) {System.out.println(Student.classRoom);}
} Java中被static修饰的成员方法称为静态成员方法是类的方法不是某个对象所特有的。静态成员一般是通过 静态方法来访问的。 【静态方法特性】 1. 不属于某个具体的对象是类方法 2. 可以通过对象调用也可以通过类名.静态方法名(...)方式调用更推荐使用后者 3. 不能在静态方法中访问任何非静态成员变量 4. 静态方法中不能调用任何非静态方法因为非静态方法有this参数在静态方法中调用时候无法传递this引用 5. 静态方法无法重写不能用来实现多态 七、代码块 使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字又可分为以下四种 普通代码块 构造块 静态块 同步代码块 普通代码块定义在方法中的代码块 public class Main{public static void main(String[] args) {{ //直接使用{}定义普通方法块int x 10 ;System.out.println(x1 x);}int x 100 ;System.out.println(x2 x);}
} 构造代码块 构造块定义在类中的代码块(不加修饰符)。也叫实例代码块。构造代码块一般用于初始化实例成员变量。 public class Student{//实例成员变量private String name;private String gender;private int age;private double score;public Student() {System.out.println(I am Student init()!);}//实例代码块{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) {Student stu new Student();stu.show();}
} 静态代码块 使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。 public class Student{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 Student(){System.out.println(I am Student init()!);}public static void main(String[] args) {Student s1 new Student();Student s2 new Student();}
} 注意 1、静态代码块不管生成多少个对象其只会执行一次 2、静态成员变量是类的属性因此是在JVM加载类时开辟空间并初始化的 3、如果一个类中包含多个静态代码块在编译代码时编译器会按照定义的先后次序依次执行(合并) 实例代码块只有在创建对象时才会执行 八、内部类 当一个事物的内部还有一个部分需要一个完整的结构进行描述而这个内部的完整的结构又只为外部事物提供服务那么这个内部的完整结构最好使用内部类。在 Java 中可以将一个类定义在另一个类或者一个方法的内部 前者称为内部类后者称为外部类。内部类也是封装的一种体现。 public class OutClass { class InnerClass{ } } // OutClass是外部类 // InnerClass是内部类 注意 1. 定义在class 类名{}花括号外部的即使是在一个文件里都不能称为内部类 public class A{ } class B{ } // A 和 B是两个独立的类彼此之前没有关系 2. 内部类和外部类共用同一个java源文件但是经过编译之后内部类会形成单独的字节码文件 根据内部类定义的位置不同一般可以分为以下几种形式 1. 成员内部类(普通内部类未被static修饰的成员内部类 和 静态内部类被static修饰的成员内部类) 2. 局部内部类(不谈修饰符)、匿名内部类 在外部类中内部类定义位置与外部类成员所处的位置相同因此称为成员内部类。 即未被static修饰的成员内部类。 class OutClass {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.同名成员名字OutClass.this.c 400;System.out.println(OutClass.this.c);}}public static void main(String[] args) {
// 外部类对象创建 以及 成员访问OutClass outClass new OutClass();System.out.println(outClass.a);System.out.println(OutClass.b);System.out.println(outClass.c);outClass.methodA();outClass.methodB();System.out.println(实例内部类的访问);
// 要访问实例内部类中成员必须要创建实例内部类的对象
// 而普通内部类定义与外部类成员定义位置相同因此创建实例内部类对象时必须借助外部类
// 创建实例内部类对象OutClass.InnerClass innerClass1 new OutClass().new InnerClass();
// 上述语法比较怪异也可以先将外部类对象先创建出来然后再创建实例内部类对象OutClass.InnerClass innerClass2 outClass.new InnerClass();innerClass2.methodInner();}
} 注意 1. 外部类中的任何成员都可以在实例内部类方法中直接访问 2. 实例内部类所处的位置与外部类成员位置相同因此也受public、private等访问限定符的约束 3. 在实例内部类方法中访问同名的成员时优先访问自己的如果要访问外部类同名的成员必须外部类名称.this.同名成员 来访问 4. 实例内部类对象必须在先有外部类对象前提下才能创建 5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用 6. 外部类中不能直接访问实例内部类中的成员如果要访问必须先要创建内部类的对象。 被static修饰的内部成员类称为静态内部类。 class OutClass {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) {
// 静态内部类对象创建 成员访问OutClass.InnerClass innerClass new OutClass.InnerClass();innerClass.methodInner();}
} 注意 1. 在静态内部类中只能访问外部类中的静态成员 如果确实想访问我们该如何做 2. 创建静态内部类对象时不需要先创建外部类对象 局部内部类 public class OutClass {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) {
// OutClass.InnerClass innerClass null; 编译失败}
} 注意 1. 局部内部类只能在所定义的方法体内部使用 2. 不能被public、static等修饰符修饰 3. 编译器也有自己独立的字节码文件命名格式外部类名字$数字内部类名字.class 九、对象的打印 public class Person {String name;String gender;int age;public Person(String name, String gender, int age) {this.name name;this.gender gender;this.age age;}public static void main(String[] args) {Person person new Person(Jim,男, 18);System.out.println(person);//打印的是:day20210829.Person1b6d3586
} class Person {String name;String gender;int age;public Person(String name, String gender, int age) {this.name name;this.gender gender;this.age age;}Overridepublic String toString() {return [ name , gender , age ];}public static void main(String[] args) {Person person new Person(Jim,男, 18);System.out.println(person);}
} 第一种直接打印对象其实是打印对象的地址第二种通过重写toString方法来打印对象。
