1. 关于继承中成员变量的访问特点
代码示例:
点击查看代码
public class Main {
public static void main(String[] args) {
Zi z=new Zi();
z.ziShow();
}
}
class Fu{
String name = "Fu";
}
class Zi extends Fu{
String name = "Zi";
public void ziShow(){
String name = "ZiShow";
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
}
2.动手实验 “==”
/1/
点击查看代码
public class Main {
public static void main(String[] args) {
int value1 = 100;
int value2 = 100;
System.out.println(value1==value2);
}
}
//------------>ture
/2/
点击查看代码
public class Main {
public static void main(String[] args) {
Foo obj1=new Foo();
Foo obj2=new Foo();
System.out.println(obj1==obj2);
}
}
class Foo{
int value = 100;
}
//------------>false;
点击查看代码
public class Main {
public static void main(String[] args) {
Foo obj1=new Foo();
}
}
class Foo{
int value ;
public Foo(int initValue){
value=initValue;
}
}
//如果类提供了一个自定义的构造方法，将导致系统不再提供默认构造方法。
点击查看代码
class Fruit {
int grams;
int calsPerGram;
Fruit() {
this(55,10);
}
Fruit(int g,int c){
grams=g;
calsPerGram=c;
}
}
//同一个类可以有多个构造函数,多个构造函数之间通过参数来区分。
// 这是方法重载的一个实例。构造函数之间可以相互调用。
点击查看代码
public class Main {
public static void main(String[] args) {
Foo obj=new Foo();
System.out.println(obj.field);
obj = new Foo(300);
System.out.println(obj.field);
}
}
class Foo{
{
field =200;
}
public int field = 100;
public Foo(int value){
this.field = value;
}
public Foo(){
System.out.println(field);
}
}
//------------>100;
//------------>100;
//------------>300;
//这是一个生造出来展示Java语法特性的示例类，在实际开发中不要这样写代码，应该尽量保证一个字段只初始化一次！
//1.执行类成员定义时指定的默认值或类的初始化块，到底执行哪一个要看哪一个“排在前面”。
//2.执行类的构造函数。
//类的初始化块不接收任何的参数，而且只要一创建类的对象，它们就会被执行。
//因此，适合于封装那些“对象创建时必须执行的代码”。
/4/类的静态初始化块
点击查看代码
public class Main {
public static void main(String[] args) {
new Leaf();
}
}
class Root
{
static
{
System.out.println("Root的静态初始化块");
}
{
System.out.println("Root的普通初始化块");
}
public Root()
{
System.out.println("Root的无参数的构造器");
}
}
class Mid extends Root
{
static
{
System.out.println("Mid的静态初始化块");
}
{
System.out.println("Mid的普通初始化块");
}
public Mid()
{
System.out.println("Mid的无参数的构造器");
}
public Mid(String msg)
{
//通过this调用同一类中重载的构造器
this();
System.out.println("Mid的带参数构造器，其参数值：" + msg);
}
}
class Leaf extends Mid
{
static
{
System.out.println("Leaf的静态初始化块");
}
{
System.out.println("Leaf的普通初始化块");
}
public Leaf()
{
//通过super调用父类中有一个字符串参数的构造器
super("Java初始化顺序演示");
System.out.println("执行Leaf的构造器");
}
}
//Root的静态初始化块
//Mid的静态初始化块
//Leaf的静态初始化块
//Root的普通初始化块
//Root的无参数的构造器
//Mid的普通初始化块
//Mid的无参数的构造器
//Mid的带参数构造器，其参数值：Java初始化顺序演示
//Leaf的普通初始化块
//执行Leaf的构造器
//由测试结果可知，其运行过程为最高父类静态，父类静态，子类静态，最高父类普通和构造函数，父类普通和构造函数，子类普通和构造函数
/5/有趣的问题
问： 静态方法中只允许访问静态数据，那么，如何在静态方法中访问类的实例成员（即没有附加static关键字的字段或方法）?
请编写代码验证你的想法。
已知：在静态方法中不能直接访问类的实例成员。但是可以通过创建类的实例来间接访问实例成员。因此如下：
点击查看代码
class MyClass {
int instanceVariable;
public MyClass(int instanceVariable) {
this.instanceVariable = instanceVariable;
}
public void instanceMethod() {
System.out.println("This is an instance method. Instance variable value: " + instanceVariable);
}
public static void staticMethod() {
MyClass obj = new MyClass(42);
System.out.println("Accessing instance variable through an object: " + obj.instanceVariable);
obj.instanceMethod();
}
}
public class Main {
public static void main(String[] args) {
MyClass.staticMethod();
}
}
//在这个例子中，静态方法staticMethod通过创建MyClass的实例来访问实例成员变量instanceVariable和实例方法instanceMethod。
点击查看代码
public class Main {
public static void main(String[] args) {
Integer i1 = 100;
Integer j1 = 100;
System.out.println(i1==j1);
Integer i2 = 129;
Integer j2 = 129;
System.out.println(i2==j2);
}
}
-------->true
-------->false
//在 Java 中，对于Integer类型的自动装箱和拆箱操作，在一定范围内的值会被缓存起来以提高性能。
//对于Integer类型，范围在-128到127之间的值会被缓存，当使用自动装箱（如Integer i1 = 100）时，如果值在这个范围内，会从缓存中获取相同的Integer对象。
//所以当比较两个在这个范围内的Integer对象使用==时，实际上比较的是同一个对象的引用，结果为true。
//而对于不在这个范围内的值，比如129，每次自动装箱都会创建新的Integer对象，所以当使用==比较两个不同的Integer对象时，结果为false。
//如果要比较Integer对象的值是否相等，应该使用equals方法。
--------------------------Moonbeams.