JAVA基础（笔记）

最新推荐文章于 2024-04-08 14:50:19 发布

江夬

最新推荐文章于 2024-04-08 14:50:19 发布

阅读量466

点赞数

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

本文链接：https://blog.csdn.net/qq_48385654/article/details/119707201

版权

这篇博客详细介绍了Java的基础，包括面向过程与面向对象的区别，面向对象的封装、继承、多态等特性。深入讲解了类、对象的创建与使用，属性、方法、构造器的细节，以及Object类中的toString和finalize方法。此外，还涵盖了单例设计模式、final关键字、抽象类和接口等内容。

摘要由CSDN通过智能技术生成

复习笔记

面向过程与面向对象

面向过程(POP) 与面向对象(OOP)

面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象的三大特征（或者四大特征）

1. 封装性

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
1.封装性思想具体的代码体现：
体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

2. 继承性

- 1.为什么要有类的继承性？(继承性的好处）
 * ① 减少了代码的冗余，提高了代码的复用性
 * ② 便于功能的扩展
 * ③ 为之后多态性的使用，提供了前提
2.继承性的格式：
class A extends B{
   }
 *    A:子类、派生类、subclass
 *    B:父类、超类、基类、superclass
3.子类继承父类以后有哪些不同？
3.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
 *  特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。
3.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
 *    子类和父类的关系，不同于子集和集合的关系。
 *    extends：延展、扩展
4.Java中继承性的说明
1.一个类可以被多个子类继承。
2.Java中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
5.子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法

3. 多态性

·方法的多态性：
方法的重载（overload）： 发生在同一类中，方法名称相同，参数个数、类型不相同。没有权限要求。即同一个方法名称可以根据参数类型或个数不同调用不同的方法体。
方法的覆写(override)： 发生在有继承关心的类之间，方法名称、参数个数、类型全相同。子类的方法权限>=父类方法权限。同一个父类方法，可以根据实例化子类的不同也有不同的实现
##·对象的多态性：
· 向上转型【自动转 90%】： 父类父类对象 = 子类实例；
通过对象向上转型可以实现接受参数的统一。
在这里插入图片描述

//向上转型
class Person{
   
    public void print(){
   
        System.out.println("1.Person类的print方法");
    }
}
class  Student extends Person{
   
    public void print(){
   
        System.out.println("2.Student类的print方法");
    }
}
public class Text7{
   
    public static void main(String[] args){
   
        Person per = new Student();//向上转型
        per.print();
    }
}
//运行结果：
//2.Student类的print方法

//参数统一化
class Person{
   
    public void  print() {
   
       System.out.println("1.Person类的print方法"); 
    }
}
class Student extends Person{
   
    public void print(){
   
        System.out.println("2.Student类的print方法");
    }
}
class Worker extends Person{
   
    public void print(){
   
        System.out.println("3.Worker类的Print方法");
    }
}
public class Text6{
   
    public static void main(String[] args){
   
        fun(new Person());//Person per = new Person();
        fun(new Student());//Person per = new Student();//向上转型   Student类 转为 Person类
        fun(new Worker());//Person per = new Worker();//向上转型     Worker 类 转为 Person类
    }
    public static void fun(Person per){
   
        per.print();
    }
}
//运行结果：
//1.Person类的print方法
//2.Student类的print方法
//3.Worker类的Print方法

是否发生了向上转型的核心在于：你使用哪一个类进行new，并且调用的方法是否被覆写。
· 向下转型【强转 1%】：子类子类对象 = （子类）父类实例；
向下转型可以实现子类扩充方法调用（有安全隐患，一般不操作！）；
父类需要子类扩充的属性或方法时需要向下转型；
在这里插入图片描述

//向下转型 将父类对象转为子类
class Person{
   
    public void print(){
   
        System.out.println("1.我是爸爸！");
    }
}
class Student extends Person{
   
    public void print(){
   
        System.out.println("2.我是儿砸！");
    }
    public void fun(){
   
        System.out.println("3.只有儿砸有！");
    }
}
public class Text8{
   
    public static void main(String[] args){
   
      Person per = new Student();//向上转型 
      per.print();//能够调用的只有父类已定义好的
      
      Student stu = (Student) per;//向下转型
      stu.fun();//
    }
}

并不是所有父类都可以向下转型，如果想要向下转型之前，一定要首先发生向上转型过程，否则会出现ClassCastException（类型转换异常属于运行时异常）。
两个没有关系的类是不能发生转型的，一定会产生ClassCastException.

instanceof类
作用：检查当前对象是否能指向目标类，返回值为Boolean。

class Person{
   
    public void print(){
   
        System.out.println("1.我是爸爸");
    }
}
class Student extends Person{
   
    public void print(){
   
        System.out.println("2.我是儿砸！");
    }
    public void fun(){
   
        System.out.println("3.只有儿砸有！");
    }
}
public class Text9{
   
    public static void main(String[] args){
   
        Person per = new Student();//向上转型
        System.out.println(per instanceof Person);
        System.out.println(per instanceof Student);
        if (per instanceof Student){
   //检查是否可转
            Student stu = (Student) per;
            stu.fun();
        }else{
   
            per=new Student();
        }
        //per.print();
        //Student stu = (Student) per;//向下转型
        //stu.fun();
    }
}

1.多态性的理解：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
举例：
Person p = new Man();
Object obj = new Date();
3.多态性的使用：虚拟方法调用
> 有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
> 总结：编译，看左边；运行，看右边。
4.多态性的使用前提：
① 类的继承关系  ② 方法的重写
5.多态性使用的注意点：
对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
************************************************************
6.多态性的应用举例：
举例一：
	public void func(Animal animal){
   //
	Animal animal = new Dog();
		animal.eat();
		animal.shout();
	}
举例二：
public void method(Object obj){
   
		
	}