Java基础篇--面向对象

面向对象的概念

---

一、面向对象的概述：

面向对象是一种程序设计方法或者程序设计规范，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计。从现实世界中客观存在的事物(即对象)出发来构造软件系统，并且在系统构造中尽力可能运用人类的自然思维方式。

二、什么是对象：

对象是系统中用来描述客观事物的一个实体，它是构成系统的一个基础单位。

三、什么是类：

把众多的事物归纳、划分成一起是人类在认识客观世界时经常采用的思维方法。

类的重要性：是java程序的基本组成单位

类是什么：是对现实生活中一类的具体共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为。例如一个学生有抽象的属性和行为：属性是年龄，姓名，性别；行为是上学，写作业。

四、包的概念和使用： 

1.包的概念：

包其实就是文件夹

2.包的作用：

对类进行分类管理

3.包的定义格式：

①格式：package 包名;（多级包用.分开）

4.带包的java类编译和执行（cmd）：

①手动建包：

按照以前的格式编译java文件        java HelloWorld.java

手动创建包                        在E盘建立文件夹com，然后在com下建立文件夹itheima

把class文件放到包的最里面            把HelloWorld.class文件放到com下的itheima这个文件下带包执行                            java com.itheima.HelloWorld

②自动建包：java -d.HelloWorld.java                java com.itheima.HelloWorld

package com.itheima;

五、导包的概述和使用： 

使用不同包下的类时，使用的时候写类的全路径，写起来太麻烦了，为了简化带包的操作，java就提供了导包的功能

1.导包的格式：

①格式：import 包名；

import java.util.Scanner;

权限修饰符 

---

一、修饰符： 

①private:可以在同一个类中访问

②默认：可以在同一个类中和同一个包中（子类无关类）访问

③protected:可以在同一个类中、同一个包中（子类无关类）和不同包的子类访问

④public:可以在同一个类中、同一个包中（子类无关类）、不同包的子类和不同包的无关类访问

private String num;
private void num(){}
String num;
void num(){}
protected String num;
protected void num(){}
public String num;
public void num(){}

 

二、final： 

final关键字是最终的意思，可以修饰成员方法，成员变量，类

1.final修饰的特点(使用的时候放到修饰词后面就可以了)：

①修饰方法：表明该方法是最终方法，不能被重写

②修饰变量：表明该变量是常量，不能再次被赋值

③修饰类：表明该类是最终类，不能被继承

2.final修饰局部变量：

①变量是基本类型：final修饰指的是基本类型的数据值不能发生改变

②变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址值里面的内容是可以发生改变的

​private final String num;
private final void num(){}
String final num;
void final num(){}
protected final String num;
protected final void num(){}
public final String num;
public final void num(){}

三、static： 

1.static关键字是静态的意思，可以修饰成员方法，成员变量

2.static修饰特点：

①被类的所有对象共享

        这也是我们判断是否使用静态关键字的条件

②可以通过类名调用

        当然，也可以通过对象名调用

3.static访问非静态的成员方法特点：

①能访问静态的成员变量

②能访问非静态的成员变量

③能访问静态的成员方法

④能访问非静态的成员方法

4.static访问静态的成员方法特点：

①能访问静态的成员变量

②能访问静态的成员方法

总结：静态成员方法只能访问静态成员

​private static String num;
private static void num(){}
String static num;
void static num(){}
protected static String num;
protected static void num(){}
public static String num;
public static void num(){}

 

一个标准对象类的格式

---

  一、对象类的组成：

类由属性和行为组成

属性：在类中通过成员变量来体现(类中方法外的变量)

行为：在类中通过成员方法来体现(去除static关键字即可)

1.属性(成员变量)的格式：

修饰符 数据类型 属性名称； 

public void name;

2.行为(成员方法)的格式： 

修饰符 返回值类型 方法名(参数1，参数2，...，参数n){

                方法体

}

参数：数据类型 数据名称

public void student(String s){
    System.out.println(s);
}

三、构造方法： 

1.构造方法的概述：构造方法是一种特殊的方法

2.作用：创建对象

3.功能：主要是完成对象的数据初始化

4.格式：

①无参构造方法：

        public 本类类名(){

}

②带参构造方法:

public 本类类名(参数1，参数2，...，参数n){

                方法体

}

5.无参构造方法和带参构造方法的区别：

无参构造方法无法直接给成员变量赋值，带参构造方法可以直接给成员变量赋值

6.注意事项：

①如果没有定义构造方法，系统将给一个默认的无参数的构造方法

②如果定义了构造方法，系统将不在提供默认的构造方法

③如果自定义了带参构造方法，还要使用无参构造方法，就必须写一个无参数的构造方法

6.推荐使用方式：

①无论是否使用，都手工写无参数构造方法 

 四、对象类的标准格式：

修饰符 数据类型 属性名称； 

  public 本类类名(){

}

public 本类类名(参数1，参数2，...，参数n){

                方法体

}

修饰符 返回值类型 方法名(参数1，参数2，...，参数n){

                方法体

}

public class student{
    public String name;
    public int age;
    public student(){
    
    }
    public Student(String name,int age){

    }
    public void homework(String name){
        System.out.println(name + "正在写作业");
    }
}

五、调用对象类格式： 

1.调用无参构造方法格式：

对象类名 自定义名 = new 对象名();

2.调用带参构造方法格式：

对象类名 自定义名 = new 对象名(参数1的数据类型 数据1，参数2的数据类型 数据2，...，参数n的数据类型 数据n);

student st = new student();//调用我参构造方法
studetn st1 = new student("张三",18);//调用带参的构造方法

 封装

封装的概述 

---

一、封装的概念：

是面向对象的三大特征之一（封装，继承，多态）；

是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作的

2.封装的原则： 

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法实现对隐藏信息的操作和访问，成员变量用private修饰，提供对应的getXxx(),setXxx()方法。

3.封装的好处： 

通过方法来控制成员变量的操作，提高了代码的安全性

把代码用方法进行封装，提高了代码的复用性

4.访问封装的成员变量的方法： 

①this:代表本类对象的引用，可以间接性给封装的成员变量赋值和访问

②访问成员变量：this.成员变量：访问本类成员变量

③访问构造方法：this(...):访问本类构造方法

④访问成员方法：this.成员方法(...):访问本类成员方法

​public class student{
    private String name;
    private int age;
    public student(){
    
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void homework(){
        System.out.println(this.name + "正在写作业");
    }
}

继承 

---

一、继承的概述：

继承是面向对象的三大特征之一。可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

二、继承的格式： 

public class 子类名 extends 父类名{}

​public class student{//父类
    public String name;
    public int age;
    public student(){
    
    }
    public Student(String name,int age){

    }
    public void homework(String name){
        System.out.println(name + "正在写作业");
    }
}


public class student1 extends student(){//子类
    public String name1;
    public student1(){

    }
    public student1(String name1){
    
    }
    public void homework(String name){
        System.out.println(name + "正在写作业");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}

三、继承中子类的特点： 

①子类可以有父类的内容

②子类还可以有自己特有的内容

四、继承的好处和弊端： 

 1.好处：

①提高了代码的复用性（多个类相同的成员可以放在同一个类中）

②提高了代码的维护性（如果方法代码需要修改，修改一处即可）

2.弊端：

①继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着发生变化，削弱了子类的独立性

五、什么时候使用继承： 

①继承体现的关系：is a 什么是什么

②假设法：我有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不能滥用

例如：

1.苹果和水果：苹果是水果中的一种

2.猫和动物：猫是动物中的一种

六、继承中变量的访问特点： 

①子类局部变量范围找

②子类成员变量范围找

③父类成员变量范围找

④如果都没有就报错（不用考虑父亲的父亲...）

七、super方法 ：

①super：代表父类存储空间的标识（可以理解为父类对象的引用）

②访问成员变量：super.成员变量：访问父类成员变量

③访问构造方法：super(...):访问父类构造方法

④访问成员方法：super.成员方法(...):访问父类成员方法

八、继承中构造方法特有的访问特点： 

1.子类中所有的构造方法默认都会访问父类中无参的构造方法

①因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类的数据初始化

②每一个子类构造方法的第一条语句默认都是：super()

 二、如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

①通过使用super关键字去显示的调用父类的带参构造方法

②在父类中自己提供一个无参构造方法

建议：自己给出一个无参构造方法

九、继承中成员方法的访问特点 ：

 1.通过子类对象访问一个方法

①子类范围内找

②父类范围内找

③如果没有就报错（不考虑父亲的父亲...）

跟访问成员变量差不多

十、Java中继承的注意事项： 

①java中类只支持单继承，不支持多继承（例如：zi extends fu,mu 这是不支持的）

②java中类支持多层继承（例如：fu extends grandpa;zi extends fu;这样是可以的）

方法重写 

---

一、方法重写概述：

Java允许你在一个类中用同一个名字定义几个方法，只要每个方法有一套唯一的参数就可以

public void sum(){
System.out.println("哈喽");
}
public void sum(String s){
System.out.println("s");
}
public void sum(int i){
System.out.println(i);
}

二、@Override： 

①是一个注解

②可以帮助我们查重写方法的方法声明的正确性

三、方法重写注意事项： 

 ①私有方法不能被重写（父类私有成员子类是不能继承的）

②子类方法访问权限要大于父类（public > 默认 > 私有）

多态 

---

一、多态的概念：

类的继承不仅仅只是定义新类的时候以你已经定义约一个类做为基础实现类的重用

就是一个父类可以用父类名去new子类出来

二、使用多态的条件：

1.对子类对象方法的调用必须通过父类的变量。

2.被调用的方法必须也是父类的一个成员。

3.在父类与子类中这个方法必须相同

4.在父类与子类中这个方法的返回类型必须相同。

5.在子类中这个方法的访问修饰符限制不能超过父类中的限制。

三、多态的格式： 

父类名 类名称 = new 子类名();

​​public class student{//父类
    public String name;
    public int age;
    public student(){
    
    }
    public Student(String name,int age){

    }
    public void homework(String name){
        System.out.println(name + "正在写作业");
    }
}


public class student1 extends student(){//子类
    public String name1;
    public student1(){

    }
    public student1(String name1){
    
    }
    public void homework(String name){
        System.out.println(name + "正在写作业");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}
public static void main(String[] args) {
    student st = new student1();//多态使用方法
}

 四、多态中成员的特点：

1.多态成员变量：编译运行看左边

2.多态成员方法：编译看左边，运行看右边

五、多态的转型： 

1.向上转型：

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

2.格式：

父类名 类名称 = new 子类名();

3.使用场景：

当不需要面对子类时，通过提供扩展性，或者使用父类的功能就能完成的相应操作

1.向下转型：

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

2.格式：

子类名 类名称 = (子类名)父类名；

3.适用场景：

当要使用子类特有功能时。

​​​public class student{//父类
    public String name;
    public int age;
    public student(){
    
    }
    public Student(String name,int age){

    }
    public void homework(String name){
        System.out.println(name + "正在写作业");
    }
}


public class student1 extends student(){//子类
    public String name1;
    public student1(){

    }
    public student1(String name1){
    
    }
    public void homework(String name){
        System.out.println(name + "正在写作业");
    }
    public void eat(){
        System.out.println("吃饭");
    }
}
public static void main(String[] args) {
    student st = new student1();//向上转型
    student1 st1 = (student1)student;
}