Java学习笔记（5）——面向对象（关键字）

最新推荐文章于 2023-03-05 10:31:38 发布
最新推荐文章于 2023-03-05 10:31:38 发布
阅读量212 收藏 1
点赞数
分类专栏： Java基础知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42506939/article/details/118807667
版权

Java学习笔记（5）——面向对象（关键字）

1 this

可以调用的结构：属性、方法；构造器
this理解为：当前对象 或 当前正在创建的对象

1.2 this调用属性、方法

  • 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。
  • 但是，通常情况下，我们都择省略"this."。
  • 特殊情况下，如果方法的形参和类的属性同名时，我们必须显式 的使用**"this.变量"的方式，表明此变量是属性，而非形参。**

1.3 this调用构造器：

  1. 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
  2. 构造器中不能通过"this(形参列表)"方式调用自己
  3. 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"
  4. 规定："this(形参列表)"必须声明在当前构造器的首行
  5. 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器

2 super

super 关键字可以理解为：父类的
可以用来调用的结构：属性、方法、构造器

2.1 super调用属性、方法：

  1. 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
  2. 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
  3. 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

2.2 super调用构造器：

  1. 我们可以在子类的构造器中显式的使用"**super(形参列表)"**的方式，调用父类中声明的指定的构造器
  2. "super(形参列表)"的使用，必须声明在子类构造器的首行！
  3. 我们在类的构造器中，针对于 "this(形参列表)"或"super(形参列表)"只能二一，不能同时出现
  4. 在构造器的首行，没显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()
  5. 在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

3 package和import

3.1package关键字的使用

  1. 为了更好的实现项目中类的管理，提供包的概念
  2. 使用package声明类或接口所属的包，声明在源文件的首行
  3. 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
  4. 每"."一次，就代表一层文件目录。
  • 补充：同一个包下，不能命名同名的接口、类。 不同的包下，可以命名同名的接口、类。

3.2 import关键字的使用

  • import:导入
  1. 在源文件中显式的使用import结构导入指定包下的类、接口
  2. 声明在包的声明和类的声明之间
  3. 如果需要导入多个结构，则并列写出即可
  4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
  5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
  6. 如果使用的类或接口是本包下定义的，则可以省略import结构
  7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
  8. 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
  9. import static:导入指定类或接口中的静态结构:属性或方法。

4 Object类

4.1 说明

  1. Object类是所Java类的根父类
  2. 如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
  3. Object类中的功能(属性、方法)就具通用性。属性：无
  • 方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()
    wait() 、 notify()、notifyAll()
  1. Object类只声明了一个空参的构造器

4.2 equals()

4.2.1 使用说明
  1. 是一个方法，而非运算符
  2. 只能适用于引用数据类型
  3. Object类中equals()的定义：
   public boolean equals(Object obj) {
	        return (this == obj);
	  }

说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

  1. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。

  2. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写.
    重写的原则：比较两个对象的实体内容是否相同.

//手动重写举例：
public class Customer {
	
	private String name;
	private int age;
	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 Customer() {
		super();
	}
	public Customer(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	//自动生成的equals()
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Customer other = (Customer) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
	
	
	//重写的原则：比较两个对象的实体内容(即：name和age)是否相同
	//手动实现equals()的重写
//	@Override
//	public boolean equals(Object obj) {
//		
		System.out.println("Customer equals()....");
//		if (this == obj) {
//            return true;
//        }
//		
//		if(obj instanceof Customer){
//			Customer cust = (Customer)obj;
//			//比较两个对象的每个属性是否都相同
			if(this.age == cust.age && this.name.equals(cust.name)){
				return true;
			}else{
				return false;
			}
//			
//			//或
//			return this.age == cust.age && this.name.equals(cust.name);
//		}else{
//			return false;
//			
//		}
//		
//	}
	//手动实现
//	@Override
//	public String toString() {
//		return "Customer[name = " + name + ",age = " + age + "]"; 
//	}
	//自动实现
	@Override
	public String toString() {
		return "Customer [name=" + name + ", age=" + age + "]";
	}
}
4.2.2 回顾 == 运算符的使用

== ：运算符

  1. 可以使用在基本数据类型变量和引用数据类型变量中
  2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
    如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
    补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

4.3 toString()方法

  1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()

  2. Object类中toString()的定义：

  public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
     }

  1. 像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息

  2. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
    举例：

//自动实现
	@Override
	public String toString() {
		return "Customer [name=" + name + ", age=" + age + "]";
	}

5 包装类

  • 定义：使基本数据类型的变量具有类的特征，引入包装类
  • 基本数据类型与对应的包装类

在这里插入图片描述

  • 类型间的转换
    在这里插入图片描述
    简易版：
    基本数据类型<—>包装类：JDK 5.0 新特性：自动装箱 与自动拆箱
    基本数据类型、包装类—>String: 调用String重载的    valueOf    (Xxx xxx)
    String—>基本数据类型、包装类:调用包装类的parseXxx(String s)
    注意：转换时，可能会报NumberFormatException
ass WrapperTest {
    public static void main(String[] args) {
        WrapperTest p = new WrapperTest();
        //p.test5();
        //System.out.println("------");
        //p.test4();
        //p.test1();
        //p.test2();
        p.test3();

    }

    //String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)

    public void test5(){
        String str1 = "123";
        //错误的情况：
//		int num1 = (int)str1;
//		Integer in1 = (Integer)str1;
        //可能会报NumberFormatException
        int num2 = Integer.parseInt(str1);
        System.out.println(num2 + 1);

        String str2 = "true1";
        boolean b1 = Boolean.parseBoolean(str2);
        System.out.println(b1);
    }

    //基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)

    public void test4(){

        int num1 = 10;
        //方式1：连接运算
        String str1 = num1 + "";
        //方式2：调用String的valueOf(Xxx xxx)
        float f1 = 12.3f;
        String str2 = String.valueOf(f1);//"12.3"

        Double d1 = new Double(12.4);
        String str3 = String.valueOf(d1);
        System.out.println(str2);//"12.3"
        System.out.println(str3);//"12.4"

    }

    /*
     * JDK 5.0 新特性：自动装箱 与自动拆箱
     */

    public void test3(){
//		int num1 = 10;
//		//基本数据类型-->包装类的对象
//		method(num1);

        //自动装箱：基本数据类型 --->包装类
        int num2 = 10;
        Integer in1 = num2;//自动装箱

        boolean b1 = true;
        Boolean b2 = b1;//自动装箱

        //自动拆箱：包装类--->基本数据类型
        System.out.println(in1.toString());//10

        int num3 = in1;//自动拆箱

    }

    public void method(Object obj){
        System.out.println(obj);
    }

    //包装类--->基本数据类型:调用包装类Xxx的xxxValue()

    public void test2(){
        Integer in1 = new Integer(12);

        int i1 = in1.intValue();
        System.out.println(i1 + 1);//13


        Float f1 = new Float(12.3);
        float f2 = f1.floatValue();
        System.out.println(f2 + 1);//13.3
    }

    //基本数据类型 --->包装类：调用包装类的构造器

    public void test1(){

        int num1 = 10;
//		System.out.println(num1.toString());
        Integer in1 = new Integer(num1);
        System.out.println(in1.toString());//10

        Integer in2 = new Integer("123");
        System.out.println(in2.toString());//123

        //报异常
//		Integer in3 = new Integer("123abc");
//		System.out.println(in3.toString());

        Float f1 = new Float(12.3f);
        Float f2 = new Float("12.3");
        System.out.println(f1);//12.3
        System.out.println(f2);//12.3

        Boolean b1 = new Boolean(true);
        Boolean b2 = new Boolean("TrUe");
        System.out.println(b2);//true
        Boolean b3 = new Boolean("true123");
        System.out.println(b3);//false


        Order1 order = new Order1();
        System.out.println(order.isMale);//false
        System.out.println(order.isFemale);//null
    }

}

class Order1{

    boolean isMale;
    Boolean isFemale;
}

6 static

6.1 介绍

static:静态的
static可以用来修饰：属性、方法、代码块、内部类

6.2 static修饰属性

按是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)

  1. 非静态属性（实例变量）我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。
  2. 静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致 其他对象调用此静态变量时，是修改过了的。

static修饰属性的其他说明：

  1. 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
  2. 静态变量的加载要早于对象的创建。
  3. 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中
  4. 静态属性举例：System.out; Math.PI;

6.3 static修饰方法

  1. 随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
  2. 静态方法中，只能调用静态的方法或属性
  3. 非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
  4. 在静态的方法内，不能使用this关键字、super关键字

7 main()

main()方法的使用说明：

  1. main()方法作为程序的入口
  2. main()方法也是一个普通的静态方法
  3. main()方法可以作为我们与控制台交互的方式。（之前：使用Scanner）

8 final

final：最终的
可以用来修饰：类、方法、变量

  1. final 用来修饰一个类:此类不能被其他类所继承。 比如：String类、System类、StringBuffer类

  2. final 用来修饰方法：表明此方法不可以被重写，比如：Object类中getClass();

  3. final 用来修饰变量：此时的**"变量"就称为是一个常量**

  • final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化

  • final修饰局部变量：

  • 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

  • static final 用来修饰属性：全局常量

9 abstract（抽象类）

  • abstract:抽象的
  • abstract可以用来修饰的结构：类、方法

abstract修饰类：抽象类

  1. 此类不能实例化
  2. 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
  3. 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

abstract修饰方法：抽象方法

  1. 抽象方法只有方法的声明，没有方法体
  2. 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
  3. 若子类重写了父类中的所有的抽象方法后，此子类方可实例化
  4. 若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

abstract使用上的注意点：

  1. abstract不能用来修饰：属性、构造器等结构
  2. abstract不能用来修饰私有方法、静态方法、final的方法、final的类
abstract class GeometricObject{
public abstract double findArea();
}
class Circle extends GeometricObject{
private double radius;
public double findArea(){
		return 3.14 * radius * radius;
};

10 interface(接口）

接口的使用

  1. 接口使用interface来定义
  2. Java中，接口和类是并列的两个结构
  3. 如何定义接口：定义接口中的成员
    JDK7及以前：只能定义全局常量和抽象方法
    全局常量：public static final的.但是书写时，可以省略不写
    抽象方法：public abstract的
    JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法

知识点1： 接口中定义的静态方法，只能通过接口来调用。
知识点2：通过实现类的对象，可以调用接口中的默认方法。如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法
知识点3：如果子类(或实现类)继承的父类和实现的接口中声明了同名同参数的默认方法，那么子类在没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。–>类优先原则
知识点4：如果实现类实现了多个接口，而这多个接口中定义了同名同参数的默认方法，那么在实现类没重写此方法的情况下，报错。–>接口冲突。这就需要我们必须在实现类中重写此方法
知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法

public void myMethod(){
	method3();//调用自己定义的重写的方法
	super.method3();//调用的是父类中声明的
	//调用接口中的默认方法
	CompareA.super.method3();
	CompareB.super.method3();
}

  1. 接口中不能定义构造器的！意味着接口不可以实例化

  2. Java开发中，接口通过让类去实现方式来使用.
    如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
    如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

  3. Java类可以实现多个接口 —>弥补了Java单继承性的局限性
    格式：class AA extends BB implements CC,DD,EE

  4. 接口与接口之间可以继承，而且可以多继承

  5. 接口的具体使用，体现多态性

  6. 接口，实际上可以看做是一种规范

public class InterfaceTest {
	public static void main(String[] args) {
		System.out.println(Flyable.MAX_SPEED);
		System.out.println(Flyable.MIN_SPEED);
//		Flyable.MIN_SPEED = 2;
		
		Plane plane = new Plane();
		plane.fly();
	}
}


interface Flyable{
	
	//全局常量
	public static final int MAX_SPEED = 7900;//第一宇宙速度
	int MIN_SPEED = 1;//省略了public static final
	
	//抽象方法
	public abstract void fly();
	//省略了public abstract
	void stop();
	
	
	//Interfaces cannot have constructors
//	public Flyable(){
//		
//	}
}

interface Attackable{
	
	void attack();
	
}

class Plane implements Flyable{

	@Override
	public void fly() {
		System.out.println("通过引擎起飞");
	}

	@Override
	public void stop() {
		System.out.println("驾驶员减速停止");
	}
	
}

abstract class Kite implements Flyable{

	@Override
	public void fly() {
		
	}
	
}

class Bullet extends Object implements Flyable,Attackable,CC{

	@Override
	public void attack() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void stop() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method1() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub
		
	}
	
}
//************************************

interface AA{
	void method1();
}
interface BB{
	
	void method2();
}

interface CC extends AA,BB{
	
}

备注：本文来自观看尚硅谷视频做的笔记。强烈推荐！

鲑鱼683
关注
专栏目录
面向对象基础2-关键字
qq_52857122的博客
03-24 299
目录 前言 一、private关键字 二、private关键字的使用 三、this关键字 四、public关键字 五、protected 六、default 总结 前言 一、private关键字 private属于私有访问权限，用于修饰类的属性和方法。 为什么要用private关键字呢？ 原因：通过对象直接访问成员变量的方式会有数据安全隐患。所以使用private关键字进行修饰。 private关键字是什么？ 是一个权限修饰符 可以修饰成员变量（成员变量和成员方法）..
Java学习笔记——面向对象
l903445981的博客
07-20 279
首先介绍了静态方法和非静态方法的调用方式，接着对static关键字进行补充介绍，然后介绍了Java是值引用的，介绍了this，super的概念，继承、多态，抽象方法与接口的定义与实现
面向对象关键字简单解释
weixin_34343000的博客
04-26 136
对象：是一个自包含的实体. 用一组可识别的特性和行为来标识。 类：就是具有相同的属性和功能的对象的抽象的集合。Class是定义类的关键字。类名称首字母要大写. 多个单词则各个首字母大写。 实例：就是一个真实的对象. 比如我们都是‘人’，而你和我其实就是‘人’类的实例了。而实例化就是创建对象的过程，使用new关键字来创建。 构造方法：又叫构造函数。实就是对类进行初始化。构造方法与类同名，无返回...
面向对象之关键字
CodeAi的博客
07-12 1100
@(笔记)[面向对象|MarkDown]07.10面向对象之关键字 new 构造方法 定义 说明 作用 实例化一个对象 static static修饰属性类变量 static修饰方法静态方法 static修饰初始化代码块 main中的static 说明 从内存的角度来看static 静态非静态成员的调用 final final修饰变量 关于引用的问题 final修饰方法 final修饰类 final
面向对象关键字
Jackson_Yi的博客
12-21 464
this关键字 this是一种特殊的引用，指向当前对象this的两种使用方法 1、如果发生局部变量可以成员变量命名冲突时， 可以通过this.成员变量名的方式区分实例变量和局部变量 2、一个构造方法中需要调用同一个类的另一个构造方法， 可以通过this()的方式调用，但this()必须要书写在第一行super关键字 super关键字super指父类对象* 使用只能在子类中使用，示例：su
Java基础笔记06——面向对象编程篇
qq_43689353的博客
05-04 893
面向对象编程
Java学习笔记03——类与对象
qq_45033269的博客
02-25 489
Java是一个面向对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型。重载（Overload）是Java中多态的一种，重载的意思是，一个类中可以有多个同名的方法，但这些方法的参数必须不同。类体由两部分组成，一部分是变量的声明，另一部分是方法的定义，对成员变量的操作只能放在方法中，但可以在声明时对成员变量赋值。数组除了可以存放基本类型，也可以直接存放引用类型，需要注意的时，数组中存放引用类型时，存放的也不是实体，而是实体的引用。类声明的变量被称为对象变量，简称。
JAVA学习笔记——面向对象编程：继承1
weixin_43410001的博客
04-05 521
目录类、超类和子类超类和子类覆盖方法子类构造器多态方法的调用过程阻止继承：final 类和方法强制类型转换抽象类受保护访问Object 类：所有类的超类equals 方法hashCode 方法toString 方法 类、超类和子类 超类和子类 关键字 extends 表明正在构造的新类派生于一个已存在的类。已存在的类称为超类 (superclass)、基类 (base class) 或父类 (parent class)；新类称为子类 (subclass)、派生类 (derived class) 或孩子类 (
JAVA学习笔记——面向对象编程：枚举类与反射
weixin_43410001的博客
04-07 589
目录枚举类定义枚举类枚举类方法反射Class 类捕获异常利用反射分析类的能力在运行时使用反射分析对象使用反射编写泛型数组代码调用任意方法 枚举类 “枚举”，顾名思义，就是一一全部列举。生活中我们时常用到“枚举”，例如性别有“男”和“女”、一星期只有周一到周日 7 天。 而在程序设计时，对于这种有固定个数取值的变量，不妨可以考虑使用枚举类。类比基本数据类型（仅仅是类比，并不完全相同），枚举类可以看作是我们自定义了一个新的“数据类型”，它的取值为有限个，类名等价于 int，我们自定义的取值等价于 int 类的各
面向对象——关键字
ZhangGeng's Blog
07-21 1499
持续整理中…… 【private】—— 私有的数据只在本类中有效。其他程序创建对象是无法直接访问的。 权限修饰符，用于 修饰成员（成员变量 和成员函数），注意 一定是 ——>成员变量 成员函数。 【this】——             当成员变量和 局部变量同名的时候，为了区分，可以使用一个关键字来完成。             this :代表的是一个对象；代表那个对象呢？
面向对象中的关键字
最新发布
LI1278的博客
03-05 366
java中的部分关键字
面向对象的关键字介绍
qq_43537005的博客
12-31 1168
面向对象编程中使用的关键字 this super abstract final static package import this关键字的使用 1.this关键字 this可以理解为：当前对象或者当前正在创建的对象(构造器中使用) 1.1 在类的方法中，我们可以使用"this.属性名"或者"this.方法"的方法，调用类中定义的属性或者方法。 通常情况下，我们都会省略"this."。特殊情况，如果方法的形参和类中定义的属性名相同时，我们必须通过"this.属性名"的方式显式调用类种定义的属性，
面向对象常见关键字
红豆的编程空间
09-26 310
final class Demo //类名 { static public $param1; //成员属性 private $param2; //成员属性 protected $param3; //成员属性 const DEMO 10; //常量 public fucntion demo () { echo $this-&gt;param3; echo self::DEMO...
面向对象---常见的关键字
qq_44779847的博客
10-24 185
1.package: 1)作用:避免类名的冲突 2)类的全称:包名.类名 3)建议:包名所有字母都小写 4)同包中的类不能同名 import: 1)同包中的类可以直接访问， 不同包中的类不能直接访问，想访问如下两种方式: 1.1)先import声明类再访问类-----建议 1.2)类的全称---------太繁琐，不建议 2.访问控制修饰符: 1)public:公开的，任何类 2)private:...
面向对象系列（一）-关键字
时光
08-06 308
类决定了对象将要拥有的属性和行为。 关键字     new         1、创建对象               ---&gt;在堆中开辟空间               ---&gt;在开辟的堆空间中创建对象               ---&gt;调用对象的构造函数         2、隐藏父类的成员         this         1、代表当前类的对象         2、...
面向对象的几个基本关键字（一）
lxh5431的博客
07-11 914
类变量：类变量在类中用static关键字声明，在任意的方法，构造函数和代码块外部类变量在程序启动时被创建，在程序结束时被销毁常量：常量是标记为final关键字的类变量，类变量的特性常量均有，再次列出与类变量的区别。 声明常量时必须赋值，且赋值后不能改变其值。 常量名称一般都需要大写。 类变量被存储在常量存储器中。实例变量：实例变量在类中被声明，在任意方法，构造函数和代码块外部在new一个对象
面向对象（封装对象private关键字）
beyond谚语的博客
03-25 1468
1.面向对象(封装的概述) A:封装概述 是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。 B:封装好处 隐藏实现细节，提供公共的访问方式 提高了代码的复用性 提高安全性。 C:封装原则 将不需要对外提供的内容都隐藏起来。 把属性隐藏，提供公共方法对其访问。 2.面向对象(private关键字的概述和特点) A:人类赋值年龄的问题 B:private关键字特点 a:是...
面向对象编程基础——Java学习笔记
"Java学习笔记是一份非常适合Java初学者的资料，主要讲解了Java的面向对象编程概念，强调了面向对象编程的优点和实践方法。笔记中涵盖了类、对象、属性和方法等基础知识，并讨论了对象的高内聚、低耦合原则以及复用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值