Java--类的成员

一、方法重载

在同一个类中,方法名相同、形参列表不同的两个多个方法之间构成重载!overload 调用方法的时候,是根据你传递的实参,来决定到底调用的是重载的哪个方法!!!

注意:
1、判断形参列表是否相同时,只看形参的类型,而不管变量名
2、是否重载和返回值类型没有任何的关系!
3、形参列表不同:个数不同或者顺序不同都是不同
4、重载其实多态中的一种情况:静态多态

void speak(){
	System.out.println("啥都不说");
}

void speak(String msg){
	System.out.println("说:" + msg);
}

以下不是重载

虽然参数名不同,但是类型不同,这不是重载,这是重复
void speak(int a){
}
void speak(int b){
}

二、构造方法

主要作用:对创建的对象做一些初始化的工作!!!
构造器、构造函数、构造方法、Constructor

构造方法的特点:

1、首先他是一个方法
2、构造方法名与类名相同!!!
3、构造方法没有返回值类型!!! 连void都不许写
4、构造方法是在创建对象  new 类名()  的时候调用的。
5、构造方法,不能通过对象.方法名()去调用。
6、构造方法也支持重载!!!

构造方法分两大类:
1、无参的构造方法:
a:如果一个类,没有显示的声明任何的构造方法,则系统会自动添加一个默认的无参构造方法。这个默认的无参构造,没有任何的实现(里面没有任何的代码)。
b:如果添加任何一个构造方法,则系统不再添加无参的构造方法。
2、有参的构造方法:

建议:写类的,总是手动添加一个无参的构造方法!!!

三、封装性

面向对象的三大特征:封装性、继承性、多态性

private 它可以用来修饰属性和方法。代表这个成员是私有。私有的成员,只能在当前的类中访问,出了类之后,别的地方没有权限进行访问。

public 修饰的属性和方法,在任何的地方都可以访问

给私有的属性,提供可读的方法
public int getAge(){
	return age;
}

public String getName(){
	return name;
}

给私有的属性,提供可写的方法
public void setAge(int a){
	age = a;
}

public void setName(String n){
	name = n;
}

setter、getter方法
通常意义上的普通类,一般都会封装属性,然后再提供相应的setter和getter方法


三、this关键字

变量访问原则:就近原则!

1、this指代当前类的对象
指代当前对象,this如果省略之后仍然指代成员变量,则可以省略。

this指代当前对象,可以调用当前对象的属性和方法!
public void eat(String food){
	System.out.println("正在吃:" + food);
}
// 对象、实例、非静态  方法
public void eat(){
	this.eat("竹子");  //这个位置的this可以省略
}

注意:如果调用一个方法的时候,没有指定对象,那么其实是省略了this
在一个类的内部,调换用自己的方法的时候,都会省略this

2、this可以在构造方法的内部去调用其他的构造方法
this(参数)

注意:
1、用this调用构造方法的时候,不能 a调用b,b再调用a
2、this调用构造方法的时候,必须放在构造方法的首行。
3、一个构造方法如果没有显示的用this去调用其他构造方法或者用super去调用
父类的构造方法,则这个构造方法,一定默认调用了父类的无参的构造方法。

3、this可以作为实参传递。代表的是当前对象的引用。

public void fun(){
    Person person = new Person();
    person.play(this);  //可以把作为参数传递到方法的内部
}

四、static关键字

static 表示静态,可以修饰属性和方法!!!被static修饰的成员称之为静态属性或静态方法。(不被static修饰:实例方法、非静态方法)

修饰属性的时候,表示这个属性是静态,这个属性就是一种公共的资源,是被所有的对象所共有。

当访问静态的成员的时候的,最标准的做法是不建议使用对象去访问静态成员!

用静态的方式去访问静态成员:类名.静态成员 。静态时随着类的加载而初始化的,只有类第一次加载到内存的时候就完成了初始化。

永远不要使用对象的方式去访问静态东西!!

访问静态永远使用类名去访问,而不要使用对象去访问。 静态的东西,已经和对象没有多大的关系。静态的东西,是属性类的, 所有静态的属性和静态方法,我们称之为:类方法和类属性

在实际中,很多的工具类都是提供了很多的静态方法来让我们使用!!!

静态不能访问非静态!!!
非静态可以访问静态!!!

在静态方法中会不会可能出现this?    不可能

static修饰代码快,称之为静态代码块!

构造代码块:
{
	System.out.println("我是代码块");
}
注意:先执行构造代码块再执行构造方法。 构造代码在实际没有使用价值

静态代码块:
static{
	System.out.println("我是静态代码块");
}
注意:静态代码块,只有类第一次加载的时候,才会调用,所以静态代码库之执行一次。 在类加载的时候,对类的静态的属性做一些初始化的工作。

总结:

类里面都可以放哪些东东?

1、实例变量(属性)
    属于对象的,只能有了对象之后才能访问。

2、静态变量(静态属性)
    不属于某个具体的对象,而是属于类的。使用静态的方式去访问:
    类名.静态

3、实例方法
    属于对象的,只有有了对象之后才能访问。

4、静态方法
    属于类。静态方法也称为类方法。 类名.静态方法。
    静态能访问非静态,非静态可以访问静态!

5、构造方法
    构造方法只有在使用new来创建对象的时候才会执行。

6、代码块
    a:构造代码块
        创建对象的时候调用,而且是优先于构造方法执行!
    b:静态代码块
        类加载到内存中的时候调用。整个生命周期中,静态代码块只执行一次。
时间: 2024-10-16 01:38:38

Java--类的成员的相关文章

Java 类中成员初始化顺序

Java 中的类成员 基本分为 静态成员, 实例变量  方法中特别的是静态方法和构造方法. 1.定义一个类 public class ClassLoaderTest { public int a ; public String b; private static int c; public  ClassLoaderTest(){ System.out.println("执行前:"+ a + "  "+ b); a = 10; b = "lisi"

java类中成员变量初始化后存放在堆内存中还是栈内存中?

答案是堆内存. 之前明明看过java类初始化过程的, 但一下子看到这样的题目,还是懵了. 百度后,那些帖子的回复各有各说, 脑袋都看得要塞住了,还是看书求证吧. 李刚的<疯狂Java>第128页开始,有一个类从初始化开始, 在内存发生什么变化的详细过程,这里简单记录一下. class Person{     String name;     static int eyeNum; } 上面这个Person类,有成员变量name和静态成员变量eyeNum了, 当执行下面语句: Person p1 

Java类的成员变量和局部变量

在Java中,成员变量和局部变量存在较大的差异性.首先,我们来看一下变量的分类图: 成员变量 成员变量被分为:类属性和实例属性. 类属性:定义一个属性时,不使用static修饰的就是实例属性, 实例属性:定义一个属性时,使用static修饰的是类属性. 类属性从这个类的准备阶段起开始存在,直到系统完全销毁这个类,类属性的作用域与这个类的生存范围相同: 而实例属性则从这个类的实例被创建开始存在,直到系统完全销毁整个实例,实例属性的作用域与对应实例的生存范围相同. PS:一个类在使用之前,要经过类加

浅谈java类中成员的初始化顺序(一)

类被创建之后的成员的初始化顺序到底是怎么样的? 首先 不考虑继承 package com; public class DemoOne { /** * 关于类的初始化顺序 */ //不考虑继承结构的情况 private static int a=1; private String str="我被赋值了"; static{ //为什么static成员函数不能访问非static变量, 不能调用非static成员函数? //静态代码块独立于对象而存在 不依赖于对象存在 简单来说可以直接以类型名

Java类的成员之四:代码块.

3.2类的成员之四:代码块 ①初始化块(代码块)作用:对Java对象进行初始化 ②程序的执行顺序: ③一个类中初始化块若有修饰符,则只能被static修饰,称为静态代码块(static block ),当类被载入时,类属性的声明和静态代码块先后顺序被执行,且只被执行一次. ④tatic块通常用于初始化static (类)属性 class Person { public static int total; static {         total = 100;//为total赋初值 } ……

【Java基础】Java类及成员和修饰符的关系

修饰符的分类 权限修饰符:private,默认的,protected,public状态修饰符:static,final抽象修饰符:abstract 类的修饰符 权限修饰符:默认修饰符,public状态修饰符:final抽象修饰符:abstract 构造方法的修饰符 权限修饰符:private,默认的,protected,public状态修饰符:final和static都不能用(由于构造方法是初始化数据的,如果为static则所有数据都可以不通过初始化一个类来访问修改,final原因待思考)抽象修

Java 类的成员初始化顺序

做个简单笔录,就当是重温下基础知识. 1.先看代码: package com.test; public class Test { public static void main(String[] args) { Son s = new Son(); } } class Parent{ int parent = 10; { System.out.println("parent中的初始化块"); } static{ System.out.println("parent中stati

Java类的成员函数调用顺序

1 class A 2 { 3 public A() 4 { 5 System.out.println("----------A 构造-------------"); 6 } 7 static 8 { 9 System.out.println("----------A 静态块-------------"); 10 } 11 { 12 System.out.println("----------A 语句块-------------"); 13 }

java类中,成员变量赋值第一个进行,其次是静态构造函数,再次是构造函数

如题是结论,如果有人问你Java类的成员初始化顺序和初始化块知识就这样回答他.下面是代码: package com.test; public class TestClass{ // 成员变量赋值第一个执行 private static int m1=1; private int m2=1; // 静态构造函数第二个执行 static{ System.out.println("成员变量赋值先于静态构造函数 m1="+m1); m1=2; } // 构造函数第三个执行 public Tes

Java类的各种成员初始化顺序如:父子类继承时的静态代码块,普通代码块,静态方法,构造方法,等先后顺

class B extends A ,然后A类也就是父类里面有静态代码块,普通代码块,静态方法,静态成员变量,普通成员变量,普通方法.子类也是这样,然后继承之后,关于程序打印输出的结果.涉及到Java类的各种成员的初始化顺序.经测试,得到如下结论: 1.父类[静态成员]和[静态代码块],按在代码中出现的顺序依次执行.2.子类[静态成员]和[静态代码块],按在代码中出现的顺序依次执行.3.父类的[普通成员变量被普通成员方法赋值]和[普通代码块],按在代码中出现的顺序依次执行.4.执行父类的构造方法