Chapter 1: Declarations and Access Control ---

最新推荐文章于 2025-11-26 21:22:25 发布
原创 最新推荐文章于 2025-11-26 21:22:25 发布 · 128 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

本文详细阐述了Java标识符的定义、组成规则、限制条件、关键字使用、大小写敏感性以及常见错误提示，帮助开发者深入理解并正确使用Java标识符。

Legal Identifiers

■ Identifiers must start with a letter, a currency character ($), or a connecting

character such as the underscore ( _ ). Identifiers cannot start with a number!

■ After the first character, identifiers can contain a

ny combination of letters,

currency characters, connecting characters, or numbers.

■ In practice, there is no limit to the number of characters an identifier can

contain.

■ You can't use a Java keyword as an identifier. Table 1-1 lists all of the Java

keywords including one new one for 5.0, enum.

■ Identifiers in Java are case-sensitive; foo and FOO are two different identifiers.

 

Complete List of Java Keywords (assert added in 1.4, enum added in 1.5)

 

 

CoreJava - Chapter 4: Objects and Classes
DreamyHacker的博客
06-14 943
Introduction to Object-Oritented Programming Introduction Each object has a specific functionality, exposed to its users, and a hidden implementation Basically, as long as an object satisfies your specifications, you don't care how the functionality is
OCP Java SE 8 Programmer II Exam Guide (Exam 1Z0-809)
01-06
Declarations, access control, and enums Object orientation Assertions and exceptions Dates, times, locales, and resource bundles I/O and NIO Generics and collections Inner classes Lambda expressions ...
Chapter 1 - Declarations and Acess Control
pigfans
07-15 159
1. Identifiers   - It must start with a letter, a currency character($), or a connection character such as the underscore(_). It cannot start with a number!. - After the first character, identifi...
Chapter 4: Routes and URLs --- Professional ASP.NET MVC 1.0
weixin_30586257的博客
06-26 508
Chapter 4: Routes and URLs --- Professional ASP.NET MVC 1.0 Overview Software developers are well known for paying close attention to the little details, especially when ...
OpenGL 4.6 comp spec chapter 1-3
努力的志 的博客
05-13 1730
文章目录1. Introduction 简介1.1 Formatting of the OpenGL Specification OpenGL规范的格式1.1.1 Formatting of the Compatibility Profile 兼容性配置文件的格式1.1.2 Formatting of Optional Features 可选功能的格式1.2 What is the OpenGL Graphics System? 什么是OpenGL图形系统1.2.1 Programmer’s Vi
2-Variables and Basic Types
gaoxiangnumber1——Gao Xiang's Blog
08-05 2266
Please indicate the source: http://blog.youkuaiyun.com/gaoxiangnumber1Welcome to my github: https://github.com/gaoxiangnumber1 Types determine the meaning of the data and operations. 2.1. Primitive Built-in
第一章介绍：Chapter1-Introduction
weixin_30426879的博客
11-18 345
第一章介绍：Chapter1-Introduction The Java TM programming language is a general-purpose,concurrent,class-based,object-oriented languag...
Cpp Chapter 15: Friends, Exceptions, and More Part1
dianzili1007的博客
11-15 141
15.1 Friends ) When you want to make class A's private members accessible to class B, let B be a friend class of A by declaring `friend class B;': class A { public: friend class B; ... } ...
Chapter 5 - Pointers and Arrays（四）
子非鱼的博客
08-31 292
5.5 Character Pointers and Functions A string constant, written as "I am a string" is an array of characters. In the internal representation, the array is terminated with the null character '
Chapter-4-Item-15-尽量减少类和成员的可访问性
学IT的细胞膜的博客
07-22 828
通过将其设置为包私有，可以使其成为实现的一部分，而不是导出的 API 的一部分，并且可以在后续版本中修改、替换或删除它，而不必担心损害现有的客户端。如果将模块的 JAR 文件放在应用程序的类路径上，而不是模块路径上，模块中的包将恢复它们的非模块行为：包的公共类的所有公共成员和保护成员都具有正常的可访问性，而不管模块是否导出包 [Reinhold,1.2]。但是，降低公共类的可访问性比减少包级私有顶级类的可访问性重要得多：公共类是包 API 的一部分，而包级私有顶级类已经是实现的一部分。
Java认证全英文考试指南： Declarations and Access Control
本资料的Chapter1便围绕这个主题展开，旨在帮助熟悉或复习Java基础知识的考生准备考试。 首先，Java程序主要由对象之间的交互构成，这些对象通过调用彼此的方法来完成任务。每种对象都有其特定的类型，该类型由类或...
Chapter 3: Introduction to Objects and Classes The Object-Oriented Paradigm Course: CS101: Java Language Programming Instructor: [Instructor Name] Date: September 22, 2025 Practical Session Objective Lab Goal: Refactor to an Object-Oriented Design Our goal is to stop using loose, primitive variables to represent our contact and instead create a proper Contact object. This is a foundational step in building professional software. Prerequisites: Java JDK 11 or higher installed. An IDE like IntelliJ IDEA or VS Code ready. Your MyContactManager project from the last lab. Final Result Preview: The console output will look exactly the same as before, but the underlying code structure will be vastly superior, organized, and ready for future expansion. Step 1: Create the Contact Class Blueprint First, we need to create the blueprint for what a "Contact" is in our application. 1. Goal: Create a new Contact.java file and define the state of a contact. 2. Instructions: 1. In your IDE's project explorer, right-click on your source folder and create a new Java Class. 2. Name the file Contact . This will generate Contact.java . 3. Inside the Contact class, declare the instance variables that every contact will have. These are the same variables that are currently cluttering up your main method. 3. Code Block (for Contact.java ): --- Contact Details --- Name: John Doe Age: 42 Phone: 555-1234 1 2 3 44. Expected Result: You now have two files in your project: MyContactManager.java and Contact.java . The code should compile without errors. Step 2: Instantiate a Contact Object Now that we have the blueprint, let's go back to our main application and create an actual contact from it. 1. Goal: In MyContactManager.java , replace the old primitive variables with a single Contact object. 2. Instructions: 1. Open MyContactManager.java . 2. Delete all the old variable declarations for the contact ( String firstName = "Jane"; , int age = 32; , etc.). 3. In their place, declare and instantiate a new Contact object. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: Your main method is now much cleaner. Your code will no longer compile because the parts that used the old variables are now broken. This is good! We'll fix it next. Step 3: Set the Object's State Our contact1 object exists, but its instance variables are all empty ( null or 0 ). Let's fill them with data using dot notation. 1. Goal: Assign values to the instance variables of our new contact1 object. public class Contact { // Instance variables to hold the state of a single contact String firstName; String lastName; int age; String phoneNumber; boolean isFriend; } 1 2 3 4 5 6 7 8 public static void main(String[] args) { // Delete the old variables: // String firstName = "Jane"; (DELETE) // String lastName = "Doe"; (DELETE) // int age = 32; (DELETE) // ...and so on. // Create an object from our blueprint Contact contact1 = new Contact(); // Now we have a single variable, 'contact1', that holds all // the information about our contact. } 1 2 3 4 5 6 7 8 9 10 11 12 132. Instructions: 1. After the line Contact contact1 = new Contact(); , use the dot operator to access each instance variable and assign it a value. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: The contact1 object in memory now holds all the data for John Doe. The code still won't compile because the System.out.println statements are broken. Step 4: Get the Object's State Finally, let's fix our print statements to read the data back from the object, again using dot notation. 1. Goal: Update the System.out.println statements to use the object's fields. 2. Instructions: 1. Find your old println statements that are showing compile errors. 2. Prefix each old variable name with contact1. to tell Java to get the value from the object. 3. Code Block (in main method of MyContactManager.java ): 4. Expected Result: All compile errors should now be gone! Your application is fully refactored. // ... after creating the contact object Contact contact1 = new Contact(); // Use dot notation to set the object's state contact1.firstName = "John"; contact1.lastName = "Doe"; contact1.age = 42; contact1.phoneNumber = "555-1234"; contact1.isFriend = false; 1 2 3 4 5 6 7 8 9 // ... after setting the object's state System.out.println("\n--- Contact Details ---"); // OLD: System.out.println("Name: " + firstName + " " + lastName); // NEW: System.out.println("Name: " + contact1.firstName + " " + contact1.lastName); // OLD: System.out.println("Age: " + age); // NEW: System.out.println("Age: " + contact1.age); // OLD: System.out.println("Phone: " + phoneNumber); // NEW: System.out.println("Phone: " + contact1.phoneNumber); 1 2 3 4 5 6 7 8 9 10 11 12 13 14Final Code and Verification Let's look at the final, refactored MyContactManager.java and verify that it works. 1. Goal: Run the application and confirm the output is correct. 2. Code Block (Complete MyContactManager.java ): 3. Expected Output: Success! The output is the same, but our code structure is infinitely better. Optional Challenge Task For Those Who Finish Early... 🚀 If you've completed the refactoring, this challenge will solidify your understanding of objects. Challenge: Create a Second, Independent Object 1. In your main method, create a second Contact object called contact2 . 2. Set the state for contact2 with completely different data (e.g., "Jane Smith", age 35, etc.). 3. Add println statements to display the details for contact2 after displaying the details for contact1 . public class MyContactManager { public static void main(String[] args) { // 1. Create an object (an instance) from the Contact class blueprint Contact contact1 = new Contact(); // 2. Set the state of the object using dot notation contact1.firstName = "John"; contact1.lastName = "Doe"; contact1.age = 42; contact1.phoneNumber = "555-1234"; contact1.isFriend = false; // 3. Get the state of the object using dot notation System.out.println("--- Contact Details ---"); System.out.println("Name: " + contact1.firstName + " " + contact1.lastName); System.out.println("Age: " + contact1.age); System.out.println("Phone: " + contact1.phoneNumber); } } 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 --- Contact Details --- Name: John Doe Age: 42 Phone: 555-1234 1 2 3 4This will prove that contact1 and contact2 are two separate objects in memory, each with its own independent state, even though they were built from the same class blueprint. Q&A and Wrap-up Questions? Today's Most Important Lesson Organizing code into classes that model real-world concepts is the single most powerful strategy for managing complexity in software. We took a chaotic collection of variables and transformed it into a clean, intuitive structure. A Contact is now a "thing" in our program, just as it is in the real world. This is the foundation upon which all large-scale, professional applications are built. What's Next? Up Next: Protecting Our Objects Right now, our code has a major flaw. Anyone using our Contact class can do this: contact1.age = -99; contact1.phoneNumber = "this is not a phone number"; This is dangerous and leads to bugs! An object should be in control of its own data. Next Lecture: Chapter 4: Deeper Dive into Classes - Encapsulation We'll learn about encapsulation, a core OOP principle for data hiding and protection. We'll introduce private variables and public getter/setter methods to create robust, bug-resistant objects. 以上问题的答案是什么
09-21
#### 1. 分析原始代码 假设原始代码使用多个独立的变量来存储联系人信息，例如： ```java // 原始代码使用独立变量存储联系人信息 String contactName = "John Doe"; String contactPhone = "123-456-7890"; String ...
MyBatis + PageHelper 分页内幕，PageHelper 是如何动态构建 LIMIT 分页 SQL 的
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
11-26 288
若依系统中有很多的表格数据、后端接口实体中并没有看到有接收分页大小和页码的属性，在系统的mapper层面SQL语句中并没有看到对应的分页限制。它是如何实现这个分页效果的呢？是将所有的数据查询出来，然后再分页吗？这样效率岂不是非常低。带着这样的疑问，稍微研究了一下这个系统的分页方法。更多详细文章后端是通过从 HttpServletRequest 对象中获取分页的页码和大小，然后创建Page分页对象，在执行sql查询的时候，动态构建分页限制条件。从而实现分页，并不是在查询到所有数据之后再进行的分页处理。
Java原生网络编程-BIO与NIO
照母山挖洋芋
11-24 808
摘要：本文对比了Java原生JDK中的BIO(阻塞I/O)和NIO(非阻塞I/O)网络编程模型。BIO采用"一连接一线程"模式，存在线程资源浪费和性能瓶颈问题，可通过线程池优化为伪异步I/O模型。NIO通过Selector、Channel和Buffer三大核心组件实现非阻塞通信，支持单线程管理多个通道。重点介绍了NIO的Reactor模式、事件类型(OP_READ/OP_WRITE等)及服务端/客户端的不同关注点，展示了NIO相比BIO在高并发场景下的优势。（149字）
Java集合框架实战：构建高效的企业管理系统
2402_83075343的博客
11-23 1039
本文通过两个企业管理系统案例，详细解析了Java集合框架的核心应用。员工部门管理系统采用HashMap实现部门与员工的高效映射，具备智能添加、快速查询和动态统计功能；商品库存管理系统基于ArrayList实现精细化管控，包含智能录入、库存预警和价格排序等特性。文章对比了HashMap和ArrayList的特性差异，提供了集合选型的最佳实践，并探讨了系统扩展方向。这两个实战案例展示了集合框架在企业应用中的实际价值，为开发者掌握Java集合提供了实用参考。
2025最新 SpringCloud 教程，教程简介，笔记01
Rockandrollman的博客
11-24 106
2025最新 SpringCloud 教程，教程简介，笔记01
AspectJ、Spring AOP 与 Solon AOP：Java AOP 框架的三剑客
向往自由的少年！（我是一个少年！！！）
11-26 278
本文对比了Java企业级开发中三种主流AOP实现：AspectJ、Spring AOP和Solon AOP。AspectJ功能最全面，支持字节码织入，可拦截各类连接点但配置复杂；Spring AOP基于动态代理，与Spring生态集成度高，但仅支持方法执行拦截；Solon AOP同样使用动态代理，采用纯注解驱动设计，更轻量但侵入性较强。选择建议：Spring项目优先Spring AOP，极致需求选AspectJ，轻量云原生场景考虑Solon AOP。三种方案各有侧重，可根据项目需求灵活选择。
Spring Boot与MyBatis
2509_94083104的博客
11-23 1083
Spring Boot是一个用于创建独立的、基于Spring的生产级应用程序的框架，它简化了Spring应用的初始搭建以及开发过程。MyBatis是一款优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。将Spring Boot和MyBatis结合使用，可以高效地开发数据驱动的应用程序。
分布式AI训练框架设计与多语言实现实践指南
最新发布
2501_94187056的博客
11-26 277
加速训练：多节点协作处理大规模数据和模型参数。资源优化：充分利用GPU/TPU和计算集群资源。可扩展性：可根据数据规模或模型复杂度扩展计算节点。多语言协作：不同模块可使用适合的语言实现，提高灵活性和性能。本文展示了分布式AI训练框架的设计与多语言实现实践：Python负责训练与分布式管理Go负责任务调度与节点管理Java处理异步参数同步C++完成计算密集型梯度计算架构整合多节点资源，实现高效分布式训练。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值