增强day03-面向对象高级

最新推荐文章于 2024-11-11 21:19:25 发布

秦川Code

最新推荐文章于 2024-11-11 21:19:25 发布

阅读量35

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/m0_57288751/article/details/134058505

版权

Java基础专栏收录该内容

20 篇文章 0 订阅

订阅专栏

关于Objetct类
Object类是所有类的父类
一切类都直接或间接继承自Object类
一个类没有使用extends关键字明确标识继承关系，则默认继承Object类
接口不继承Objetct类
所有类都可以继承Object中允许被继承的方法
Objetct类定义了toString()、equals()、HashCode()方法
Objetct类在java.lang包中
关于外部类和内部类成员的相互访问的规则
内部类可以直接访问外部类的成员
外部类可通过创建内部类的实例来访问内部类的成员
关于泛型的定义
class Test1 {}，这是一个泛型类
interface Test2 {}，这是一个泛型接口
lass Test3{ void test () {}}，这是一个泛型方法，当然我知道这很抽象，举个例子

<T> void printElement(T element) {
    System.out.println(element);
}
嗯，泛型方法就长这样，
需要我们在void前面加一个泛型参数<T>

还是泛型的定义，我们来看一段代码

如何理解这三个方法？

public Result<T> test(){ return null; }
这是一个普通的公共方法，它返回一个泛型类型为Result<T>的对象。
这个方法可以被类内部和外部的代码调用。

public <T> Result<T> test(){ return null; }
这是一个泛型方法，它在方法名之前有一个类型参数<T>。
这意味着你可以在调用这个方法时传入一个具体的类型。
例如，如果你调用test()并传入了一个String类型，那么方法将返回一个Result<String>类型的对象。

public static <T> Result<T> test(){ return null; }
这是一个静态的泛型方法。它与第二个方法相似，但被声明为静态的。
静态方法属于类而不是实例，所以你可以在没有类实例的情况下调用它。
例如，你可以通过ClassName.test()的方式调用它。

总结
第一个方法是一个普通的泛型方法，可以被实例调用。
第二个方法也是一个泛型方法，但它可以在调用时传入类型参数，可以灵活地返回不同类型的Result<T>。
第三个方法是一个静态的泛型方法，可以在没有类实例的情况下调用，也可以在调用时传入类型参数。

关于匿名内部类
匿名内部类是内部类的简化形式
匿名内部类的前提是必须要继承父类或者实现接口
匿名内部类的格式是"new父类(参数列表)或父接口（）{}"
匿名内部类内部没有构造方法，因为他们没有类名，不能被直接调用。匿名内部类的实例是通过匿名类的构造方法来创建的，这个构造方法是由编译器生成的。
关于泛型定义的深入理解

先说结论：泛型类中的静态方法不能使用类的泛型，而应该将该方法定义为泛型方法 
错误示范：
class demo<T>{
    public static T show(T temp) {
        return temp;
    }
} 

正确示范：
class demo<T>{
    public static <T> T show(T temp) {
        return temp;
    }
} 

仔细观察上面两个例子，第二个正确例子是不是在static后面加上了<T>？
这就是关键，加上<T>之后，静态方法-->泛型方法，就可以使用非静态变量了！

就泛型类而言，类实例化时才能传递真正的类型参数，由于静态方法的加载先于类的实例化，也就是说类中的泛型还没有传递真正的类型参数时，静态方法就已经加载完成。显然，静态方法不能使用/访问泛型类中的泛型。

为什么内部类里面的成员变量和成员方法不能用static修饰？
因为内部类说白了就是外部类的实例，相当于外部类的成员变量，每个实例出来的对象，它的成员变量赋值都是互相独立的，互相不会影响
如果我们允许内部类static的成员变量存在，那么在赋值的时候就会混乱！

class Employee {
    public String name;
    class InnerData {
       public static count; // ??? count of which ? a or b? 
     }
}

Employee的内部类InnerData里面有一个静态变量count
我们new一个外部类：Employee a = new Employee(); 
然后给a的count赋值：a.new InnerData().count=3
再new一个外部类：Employee b = new Employee(); 
然后给b的count赋值：b.new InnerData().count=4
这时候是不是就混乱了？我给b赋值的时候把a的count也给修改了，因为他们公用一个count在内存中

如果我们想要内部类里面的成员变量或者方法用static修饰，那么内部类也要用static修饰
还有一句话也很重要：无法从static上下文引用非static上下文
简介的介绍一下Java的修饰权限：
private: 具有最低权限，只在声明它的类内部可见。
default (没有修饰符): 也称为包级访问权限。在同一包内可见，不可以跨包访问。
protected: 对同一包内的类和所有子类可见。不同包中的子类也可以访问，但前提是子类要继承父类。
public: 具有最高权限。被声明为 public 的类、方法、变量可以被任何其他类访问。
Object类的常见方法：
equals(Object obj) - 用于比较两个对象是否相等。
toString() - 用于返回对象的字符串表示。
hashCode() - 返回对象的哈希码值。
getClass() - 返回对象的运行时类。
clone() - 用于创建并返回此对象的一个副本。
finalize() - 在垃圾收集器删除对象之前调用。
notify() - 唤醒等待中的单个线程。
notifyAll() - 唤醒等待中的所有线程。
wait() - 导致当前线程等待直到另一个线程调用 notify() 或 notifyAll() 方法。
wait(long timeout) - 导致当前线程等待直到另一个线程调用 notify() 或 notifyAll() 方法，或者指定的时间已经过去。
关于基本类型和包装类
基本数据类型不能调用方法，但可以通过对应的包装类进行方法调用。

字符串转换成整型
String str = "123";
Integer a = Integer.parseInt(str);

整型转换成字符串
int a = 123;
String str = a.toString;//走的Integer的类
String str = Integer.toString(a);//走的Integer的类
String str = String.valueof(a);//走的是toString
String str = a+"";