✨✨谢谢大家捧场,祝屏幕前的小伙伴们每天都有好运相伴左右,一定要天天开心哦!✨✨
🎈🎈作者主页: 🎈丠丠64-CSDN博客🎈
✨✨ 帅哥美女们,我们共同加油!一起进步!✨✨
目录
一、前言
二、类
类是自定义类型,就是类似一种模型,对一个实体来进行描述,实例化出的对象 占用实际的物理空间,存储类成员变量
1.类的定义
// 创建类class ClassName {field ; // 字段 ( 属性 ) 或者 成员变量method ; // 行为 或者 成员方法}
class Student {
//成员属性
public String name;
public int age;
public String sex,
//成员方法
public void input Student(){
System. out. println("该学生的名字:"+ this.name +"()"+ this.sex + "->"+ this.age);
}
public void Doclass(){
System. out.println(this.name +"按时上课");
}
public void DoHomework(){
System.out.println(this.name +"按时完成作业");
}
public void Exam(){
System.out.println(this.name +"诚心考试");
}
}
这就是一个关于描述学生的一个类,里面有成员属性以及成员方法,而在一般的文件中往往只定义一个类
2.类的实例化
使用类创建一个对象的过程就称为类的实例化,可以理解为定义了一个新的类型,在java中采用new关键字,配合类名来实例化对象
Student stul = new Student():
Student stu2 = new Student();
stul.age = 18;
stul.name="小明";
stul.sex="男";
stul.input Student();
stul.DoClass();
stul.Exam();
stu1.DoHomework();
stul.age = 15;
stul.name ="小美";
stul.sex="女";
stul.input Student();
stul.DoClass();
stul.Exam();
stul.DoHomework();
上述就为new 关键字用于创建一个对象的实例化了两个对象,使用点来访问对象中的属性与方法,同一个类可以创建对个实例。
3.this引用
为什么上面要用this引用呢,我们来看个案例
class Date{
public int year;
public int month,
public int day;
public void SteDay(int year,int mmonth, int day){
//设置哪个对象
year = year;
month = month;
day = day;
}
public void printDate(){
System.out.println(year +"/"+ month +"/"+ day); //打印哪个对象
}
}
当形参名字与成员变量名字相同时,赋值的主体和客体就不清楚了,所以就是要限定一下,
class Date{
public int year;
public int month;
public int day;
public void SteDay(Date this,int year,int mmonth, int day){//date this 为隐藏属性
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(Date this){
System.out.println(this.year + "/"+ this.month + "/"+ this. day);
}
}
加上this引用可以避免很多错误,很好的代码习惯,可以培养一下这个习惯
三、对象构造与初始化
1.对象的默认值
前面我们学过在JAVA中的对象定义好了以后,必须进行初始化以后才可以使用,不然会报错,但是在类中的变量,定义好以后,并不会报错,因为它都会有一个默认值,对象空间被申请好之后,对象中包含的成员已经设置好了初始值
数据类型 | 默认值 |
---|---|
byte | 0 |
char | '\u0000' |
short | 0 |
int | 0 |
long | 0L |
boolean | false |
float | 0.0f |
double | 0.0 |
reference | null |
2.对象的构造
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 Date(int year,int month){ //带二个参数的构造方法
this.year = year;
this.month = month;
System. out.println("调用了Date(int,int)这个方法");
}
public Date(int year){ //带一个参数的构造方法
this.year = year;
System. out.println("调用了Date(int)这个方法");
}
public Date(){ //不带参数的构造方法
System. out.println("调用了Date()这个方法");
}
}
构造方法的作用是对对象初始化,并不对其开辟空间,并且构造方法时候可以重载,名字相同参数不同,构成了方法的重载,但值得一提的是,当我们没有自己任何构造,JAVA会默认生成一份无参的构造方法,一旦用户构造了一种方法,则编译器不会再生成
当然也可以使用this调用其他构造方法来简化代码
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 Date(){
this(2004,8,24)
System. out.println("调用了Date()这个方法");
}
}
public class Test
public static void main(String[] args){
Date d= new Date();
d.printDate();
}
}
在用this调用的时候有几个注意的事项,this语句必须位于构造方法的第一条不然会报错,调用的方法必须构造方法中的其中一个,不能相互调用形成环编译器会报错。
构造方法的类型是由顺序决定的,好比从上到下d1为三个参数的构造方法,后面的所有构造方法均为三个参数的构造方法,就像出生一样,整个对象的生命周期内只调用一次,输入不符合的参数就会报错
Date dl= new Date(2004,8,24);
d1.printDate();
Date d2 = new Date(2004,8);
d2.printDate();
Date d3 = new Date(2004);
d3.printDate();
Date d4 = new Date();
d4.printDate();
3.构造的快捷方法
如果一个类中的属性很多,我们不好去一条条写出来方法,我们就可以使用快捷方法来自动生成方法,只需要写好成员属性
public String name ;
public int age;
public String sex;
public String hight ;
public Student(String name,int age, String sex, String hight){
this.name = name;
this. age = age;
this.sex = sex;
this.hight = hight ;
}
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age = age;
}
public String getSex(){
return sex;
}
点点鼠标就可以生成这些代码,使我们需要的时候调用方法就行,会很方便
四、封装
1.访问限定符
JAVA中主要使用类访问限制权限来实现封装,类可以将数据以及封装数据的方法结合在一起,访问权限用来控制方法或者字段能否直接在类外使用
范围 | private | default | protected | public | |
---|---|---|---|---|---|
1 | 同一包同一类 | √ | √ | √ | √ |
2 | 同一包不同类 | √ | √ | √ | |
3 | 不同包的子类 | √ | √ | ||
4 | 不同包的非子类 | √ |
2.包
就是为了更好的管理,将多个类整合在一起成为一组,包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,在同一个工程中允许存在相同名称的类,只要处在
Java 中已经提供了很多现成的类供我们使用,使用import语句导入包
import java.util.Date;
public class Test {
public static void main(String[] args){
Date date= new Date();/! 得到一个亳秒级别的时间戳
System.out.println(date.getTime());
}
}
如果要使用util这个包中的其他类,可以这样写
import java.util.*;
public class Test {
public static void main(String[] args){
Date date= new Date();/! 得到一个亳秒级别的时间戳
System.out.println(date.getTime());
}
}
需要什么类,会自动在这个包中寻找
但是呢,这样的写法,当两个包中的类出现相同的类名时,会产生歧义,出现冲突
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args){
Date date= new Date();/! 得到一个亳秒级别的时间戳
System.out.println(date.getTime());
}
}
就要这样解决,所以还是更建议显式的指定要导入的类名
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args){
java.until.Date data = new java.util.Date();/! 得到一个亳秒级别的时间戳
System.out.println(date.getTime());
}
}
3.自定义包
在文件的最上方加上一个 package 语句指定该代码在哪个包中 .包名需要尽量指定成唯一的小写名字 , 通常会用颠倒形式 ( 例如 com.xian.www ).
六、static成员
我们上述说的都属于非静态成员,如果一个类中的某个成员属性都是共用的,就不需要依靠对象。
class Student {
//非静态属性
public String name;
public int age;
public String sex;
//静态属性
public static String classroom="109";
}
public class Test
public static void main(String[] args)
Student stul = new Student()
Student stu2 = new Student()
stul.age = 18;
stul.name="小明";
stul.sex="男";
stul.age = 15;
stul.name = ="小美";
stul.sex="女";
}
}
public class Test
public static void main(String[] args){
System.out.println(Student.classroom);
}
}
五、代码块
1.普通代码块
public class Test { public static void main(String[] args){{
//这就是一个代码块 { }扩起来的部分
}
}
}
2.构造块
class Student{
public String name;
public int age;
public String sex;
public static int classroom;
public Student(){
System. out.println("构造方法");
this.name = "liming";
this.age = 12;
this.sex="man";
System.out.println("实例代码块");
}
statici{
classroom= 109;
System.out.println("实例静态代码块");
}
public void input_Student(){
System. out.println("该学生的名字:"+ this.name + "()" + this.sex + "->" + this.age);
}
}
3.静态块
- 静态代码块不管生成多少个对象,其只会执行一次
- 如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行
- 实例代码块只有在创建对象时才会执行
最后从结果我们可以得出结论,在执行代码过程中,实现的先后顺序应该是
静态代码块 > 代码块 > 构造方法
六、对象的打印
@Override
public String toString(){
return "Student {" + name = "+ name + "age = " + age + "sex = " + sex + "}"
}
public class Test {
public static void main(String[] args){
Student stu = new Student();
stu.toString();
}
}
这样就可以直接打印出来
七、内部类
public class OutClass {class InnerClass {}}// OutClass 是外部类// InnerClass 是内部类
1.匿名内部类
我们构造了一个接口A,在Test5类内部中重写A,这样的就叫做匿名内部类
interface A{
void test();
}
public class Test5 {
public static void main(String[] args){
new A(){
@Override
public void test() {
System.out.println("hehehhehehehheheheh");
}
}.test();
}
}
2.实例内部类
public class OutClass {
class InnerClass{
}
}
外部类中的任何成员都可以在实例内部类方法中直接访问
public class OutClass {
public int num1 = 1;
static int num2 = 2;
class InnerClass{
int num3 = 3;
public void methodInner(){
num1 = 100;
num2 = 200;
System.out.println(num1);
System.out.println(num2);
}
}
}
在实例内部类方法中访问同名的成员时,优先访问自己的,如果要访问外部类同名的成员, 必须:外部类名称.this. 同名成员来访问
public class OutClass {
int num3 = 3;
class InnerClass{
int num3 = 3;
public void methodInner(){
num3 = 300;
System.out.println(num3); //优先访问自己内部的
System.out.println(OutClass.this.num3); //加外部类名加this是外部
}
}
3.内部类实例化
OutClass.InnerClass innerClass = new OutClass().new InnerClass();
innerClass.methodInner();
4.静态内部类
public class OutClass {
static class InnerClass{
}
}
静态内部类内部只能访问外部类的静态成员
public class OutClass {
public int num1 = 1;
static int num2 = 2;
static class InnerClass{
public void methodInner(){
num1 = 100;
num2 = 200;
System.out.println(num1);
System.out.println(num2);
}
}
}
我们可以发现访问非静态成员会报错
创建静态内部类对象时,不需要先创建外部类对象
OutClass.InnerClass innerClass = new OutClass.InnerClass();
innerClass.methodInner();
希望对你有用