java面向对象基础

╰半夏微凉° 2022-11-14 10:26 226阅读 0赞

# 类与实例 #

类可以理解为一个具有被描述对象(们)自身(共有的)属性、行为的一个集合。

比如说 狗类，就有`尾巴`，`毛`等属性，有`吃骨头`，`吃粑粑`等行为。放在代码里来看，就是`尾巴`和`毛`的变量以及`吃骨头`，`吃粑粑`的方法。

实例化则可以理解为通过`new`关键字将该类从概念实例化为了一个存在的对象，狗本身是一个泛指(事物的概念)，当我们new过了之后，它就是我们身边蹦跶的宠物犬了(具体的事物)

# 构造方法 #

又称构造函数，其功能就是对类进行初始化。构造方法与类同名，无返回值，在`new`的时候调用。

class Dog{ 
    	private String name = "";
        
        // 该方法就是Dog类的构造方法
        public Dog(String name){ 
    		this.name = name;
        }
        
        public String Eat(){ 
            return "我叫"+name+"，我爱吃粑粑";
        }
    }
    
    Dog dog = new Dog();
    // new 后边的Dog()其实就是Dog类的构造方法

所有的类都有构造方法，如果我们不编码，则系统默认生成空的构造方法。若有定义的构造方法，则默认的构造方法则失效。

# 方法的重载 #

方法的重载其实就是允许我们创建多个**同名**但**参数的个数或者类型**不同的方法。

方法的重载可以允许我们在**不改变原有类的方法**的基础上**对类进行扩展**。

class Dog{ 
    	private String name = "";
        
        public Dog(String name){ 
    		this.name = name;
        }
        
        // 该方法是对Dog类构造方法的重载
        public Dog(){ 
    		this.name = "无名氏";
        }
        
        public String Eat(){ 
            return "我叫"+name+"，我爱吃粑粑";
        }
    }
    
    Dog dog = new Dog();

# 修饰符 #

java中的修饰符

*  **default** (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
 *  **private** : 在同一类内可见。使用对象：变量、方法。 **注意：不能修饰类（外部类）**
 *  **public** : 对所有类可见。使用对象：类、接口、变量、方法
 *  **protected** : 对同一包内的类和所有子类可见。使用对象：变量、方法。 **注意：不能修饰类（外部类）**。

# 封装 #

每个对象都包含它能进行操作所需要的所有信息，这个特性称为封装，因此对象不必依赖其他对象来完成自己的操作。

好处：

一、良好的封装能够减少耦合

二、类内部的实现可自由修改

三、类有清晰的对外接口

# 继承 #

\*\*对象的继承代表了一种 is-a 的关系。\*\*比如狗是宠物，这时狗就可以继承宠物类。\*\*继承者可以理解为被继承着的特殊化。\*\*除了宠物所共有的一些属性外，狗狗还会吃粑粑。

当我们使用继承时

一、子类可以拥有父类非private的属性和方法

二、子类拥有自己的属性和功能

三、子类可以以自己的方式实现父类的功能(方法重写)

虽然继承**避免了重复代码**，将公共部分写在了父类，但**当父类发生改变时，子类也不得不跟着改变**。而且当我们使用继承时，会使得父类的细节暴露给子类，破坏封装。

# 多态 #

多态这一块属实抽象。多态体现为**父类引用变量可以指向子类对象**。结合网上的讨论和自己的理解，我认为多态可以理解为一种**扩展**，可以**体现在相同的方法被不同的类调用后得出不同的结果**。

多态的**前提条件是存在子父级关系**。还拿小狗狗举例，狗狗是宠物的子类，但是宠物难道只有狗狗一种吗？当然不，还有兔兔。毫无疑问的是，狗狗和兔兔都会吃，但是狗狗吃的是粑粑，兔兔吃的是草草。

假如宠物类为

class Pet{ 
    	protected String name = "";
        
        public Pet(String name){ 
    		this.name = name;
        }
        
        public Pet(){ 
    		this.name = "无名氏";
        }
        
        public String Eat(){ 
            return "";
        }
    }

然后我们的狗狗为

class Dog extends Pet{ 
    	private String name = "";
        
        public Dog(String name){ 
    		this.name = name;
        }
        
        // 该方法是对Dog类构造方法的重载
        public Dog(){ 
    		this.name = "无名氏";
        }
        
        @Override
        public String Eat(){ 
            return "我叫"+name+"，我爱吃粑粑";
        }
    }

兔兔为

class Rabbit extends Pet{ 
    	private String name = "";
        
        public Rabbit(String name){ 
    		this.name = name;
        }
        
        // 该方法是对Dog类构造方法的重载
        public Rabbit(){ 
    		this.name = "无名氏";
        }
        
        @Override
        public String Eat(){ 
            return "我叫"+name+"，我爱吃草草";
        }
    }

实例化的时候

可以看到，同一种方法，出现了不同的结果。

**多态的转型**

多态的转型分为向上转型和向下转型两种

向上转型：多态本身就是向上转型过的过程

*  使用格式：父类类型 变量名=new 子类类型();
 *  适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。

向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型

*  使用格式：子类类型 变量名=（子类类型） 父类类型的变量；
 *  适用场景：当要使用子类特有功能时。

# 重构 #

这里我们不难发现，狗狗和兔兔都可以吃东西，区别在于吃的东西不一样。假如此时我们需要将 `我叫`改为`我的大名是`的话，我们则需要改动所有继承Pet的子类代码，这谁顶得住啊。

这时，我们便应该将`Eat()`和子类做一些改动，在抽出公共部分的同时，来实现吃的东西不一样。

class Pet{ 
    	protected String name = "";
        
        public Pet(String name){ 
    		this.name = name;
        }
        
        public Pet(){ 
    		this.name = "无名氏";
        }
        
        public String getFood(){ 
            return ""
        }
        
        public String Eat(){ 
            return "我叫"+name+"我爱吃"+getFood();
        }
    }

子类重写父类的`Eat()`方法

class Dog extends Pet{ 
    	private String name = "";
        
        public Dog(String name){ 
    		this.name = name;
        }
        
        // 该方法是对Dog类构造方法的重载
        public Dog(){ 
    		this.name = "无名氏";
        }
        
        @Override
        public String getFood(){ 
            return "粑粑"
        }
    }

# 抽象类 #

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

比如我们`new()`一个`Pet`类，相当于我们实例化了一个宠物出来，但是这个宠物长什么样？喜欢吃啥，是完全不知道的。这时候，`Pet`这个类就可以座位一个抽象类去用。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。

**抽象类总结规定**

*  抽象类不能被实例化，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
 *  抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
 *  抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
 *  构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
 *  抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

# 接口 #

接口是**把隐式公共方法和属性组合起来，以封装特定功能的一个集合**。一旦类实现了接口，类就可以支持接口所指定的所有属性和成员。声明接口在语法上与声明抽象类完全相同，但不允许提供接口中任何成员的执行方式。所以接口不能实例化，不能有构造方法和字段:不能有修饰符，比如 public、private等;不能声明虚拟的或静态的等。还有**实现接口的类就必须要实现接口中的所有方法和属性**。

一个类可以支持多个接口，多个类也可以支持相同的接口

假如我们养了一个大天狗和九命猫(没错我就是阴阳师玩家，没玩过的可以理解为有技能的狗和猫)，大天狗和九命猫继承了宠物类Pet，但是他们会放法术，那怎么办呢？总不能在Pet类加上法术吧。

所以这时候，就需要用到接口了。

我们可以创建一个接口，来为特殊宠物实现放技能的能力，而不影响到可爱的旺财。

public interface skill { 
    	String useSkill();
    }

定义一下我们的大天狗类

public class DaTianGou extends Pet implements skill{ 
    	private String name = "";
        
        public DaTianGou(String name){ 
    		this.name = name;
        }
        
        // 该方法是对Dog类构造方法的重载
        public DaTianGou(){ 
    		this.name = "无名氏";
        }
        
        @Override
        public String getFood(){ 
            return "寿司";
        }
        
    	public String useSkill(){ 
    		return this.name + "使用了刮痧";
    	}
    }

实例化

public static void main(String[] args) { 
            Pet dog = new Dog("旺财");
            System.out(dog.Eat());			//我叫旺财，我爱吃粑粑
            Pet ribbit = new Rabbit("小白");
            System.out(ribbit.Eat());		//我叫小白，我爱吃草草
         	DaTianGou dtg = new DaTianGou("大天狗");
        	System.out.println(dtg.Eat())	//我叫大天狗，我爱吃寿司
            System.out.println(dtg.useSkill());	//大天狗使用了刮痧
        }

--------------------

*  看完接口和抽象类，难免会有些困惑。他们的区别在哪呢？
 *  抽象类可以给出一些成员的实现，接口却不包含成员的实现
 *  抽象类的抽象成员可被子类部分实现，接口的成员需要实现类完全实现
 *  一个类只能继承一个抽象类，但可实现多个接口等等。

但这些都是从两者的形态上去区分的。我觉得还有三点是能帮助我们去区分抽象类和接口的。

第一，类是对对象的抽象;抽象类是对类的抽象;接口是对行为的抽象。接口是对类的局部（行为）进行的抽象，而抽象类是对类整体（字段、属性、方法)的抽象。如果只关注行为抽象，那么也可以认为接口就是抽象类。总之，不论是接口、抽象类、类甚至对象，都是在不同层次、不同角度进行抽象的结果，它们的共性就是抽象。

第二，如果行为跨越不同类的对象，可使用接口;对于一些相似的类对象，用继承抽象类。

第三，从设计角度讲，抽象类是从子类中发现了公共的东西，泛化出父类，然后子类继承父类，而接口是根本不知子类的存在，方法如何实现还不确认，预先定义。

所以说，实现接口和继承抽象类并不冲突

# 泛型 #

泛型是具有占位符(类型参数)的类、结构、接口和方法，这些占位符是类、结构、接口和方法所存储或使用的一个或多个类型的占位符。泛型集合类可以将类型参数用作它所存储的对象的类型的占位符:类型参数作为其字段的类型和其方法的参数类型出现。

通常情况下，都建议使用泛型集合，因为这样可以获得类型安全的直接优点而不需要从基集合类型派生并实现  
类型特定的成员。此外，如果集合元素为值类型，泛型集合类型的性能通常优于对应的非泛型集合类型  
(并优于从非泛型基集合类型派生的类型)，因为使用泛型时不必对元素进行装箱。