java基础（三）——面向对象

最新推荐文章于 2023-03-11 21:11:56 发布

二龙山扛把子

最新推荐文章于 2023-03-11 21:11:56 发布

阅读量263

点赞数 1

分类专栏：编程文章标签： java基础面向对象

本文链接：https://blog.csdn.net/qq_37147393/article/details/79078577

版权

编程专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1）面向对象与面向过程

面向过程(Procedure Oriented)：分析出解决问题所需要的步骤，然后用函数逐步实现，再依次调用就可以了。
例如：做面包
面向过程将其分为找面粉——>打鸡蛋——>和面——>烘烤——>取面包——>烘干
面向对象(Object Oriented,OO)：把构成问题的各个事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙一个事物在整个解决问题的步骤中的行为。
同样是做面包：
面向对象将其分为：将材料放入面包机——>时间到了取面包。
两者区别：面向过程注重于实现过程的细节；面向对象更注重于对于对象方法的调用。

2)面向对象的三大特性

面向对象的三大特性为：封装，继承，多态
①封装：强调的是隐藏对象的属性和实现细节，仅对外保留公共访问方式。
好处：提高代码复用性；提高安全性；
实现方式：通常将类中的成员变量私有化，向外提供set，get方法来进行访问。

public class UsePrivate {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
     Car car=new Car();
     car.setBrand("宝马");
     car.setColor("黑");
     System.out.println(car.getBrand()+",的颜色是："+car.getColor());
    }

}
class Car{
    private String color;
    private String brand;
    public Car(){

    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }

    }

注意：各个关键字的访问权限：

private它的权限范围仅在同一个类内部；
default它的范围在同一个包中；
protected他的范围在一个包中与他的子类中；
②继承（inheritance）
定义：现实世界对客观事物之间关系的一种描述，继承关系其实就是一种从一般到特殊的关系
泛化：将不同子类的共性抽象成父类的过程。
特点：1.单继承性：即一个子类只有一个父类；
2.只可以继承父类的所有非私有成员，。
3.不能继承父类的构造方法但可以通过super去访问。
注：接口弥补了单继承的缺陷。

   class Person{
    int age;
    String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
 class Student extends Person {

    public Student()
    {

    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void eat()
    {
        System.out.println(age);
    }
    public void study(){
        System.out.println("学生很能学");
    }
    public void playGames(){
        System.out.println("学生很能玩");
    }
} 
/*
*主方法调用
*/
public static void main(String[] args) {
        // TODO Auto-generated method stub
       Student s=new Student();
       s.setAge(141);
       System.out.println(s.getAge());
       s.setName("郜");
       System.out.println(s.getName());
    }

③多态（polymorphism）
定义:事物存在的多重形态，即同一种事物由于条件不同，产生的结果也不相同。在代码中，则是同一个引用类型，利用不同的实例而执行不同的操作。
必要条件：1.要有继承关系
2.要有方法重写
3.要有父类引用指向子类对象
多态中的成员访问特点：
A:成员变量
编译看左边，运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边。
D:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)
由于成员方法存在方法重写，所以它运行看右边。

  public  int age=12;
   String name;

   public  void makeMonkey(){
       System.out.println("我要赚钱");
   }
}
class Son extends Father{
    public int age=15;
    @Override
   public  void makeMonkey(){
       System.out.println("我要赚很多钱钱");
   }
}
  public class TestPolymorphism {

    public static void main(String[] args) {
        Father father=new Father();
        System.out.println(father.age);
        Son son=new Son();
        System.out.println(son.age);
        Father person=new Son();
        System.out.println(person.age);
    }
}

3)构造函数，重载，重写区别

①概念
构造函数：构造方法是一种特殊的方法，他的名字必须与它所在的类的名字完全相同，而且没有类型，构造函数也是一种特殊的重载。
注：每个类加载时会自动生成一个无参构造函数，当重载后构造函数会被覆盖掉。
重载(OverLoad)：一个类中可以有多个方法的具有相同的名字，但是这些方法的参数必须不同，或是参数个数不同，或是参数类型不同。
重写(Override)：也称方法覆盖，隐藏以继承的实例方法。子类除了方法体内部可以不同，其他必须相同。
注：成员变量也可以通过定义相同的成员变量名对父类的成员进行隐藏(类型可以不同)

class Father{
 public  int sa=22;
}
class Son extends Father{
 public String sa="121";
}
class UseSon{
public static void main(String[] args){
   Son son=new Son();
   System.out.println(son.sa);
}
}

②三者区别
1.构造函数与重载区别
相同：一. 构造函数与重载可以拥有多个相同名字的函数；
二.且他的参数列表会发生变化
不同：一.构造函数他的名字必须与类名相同，且没有返回值类型；
二.重载无此类要求
2.重载与重写区别
相同：基本没有
不同：一.重写必须在子类中；重载没有；
二. 重载的参数列表会发生变化；但是重写必须与父类的返回类型，相同参数列表，访问修饰符的限制一定要大于被重写方法的访问修饰符。
构造函数

class Father{
     String name;
     int age;
     public Father(){
     }
     public Father(String name){
      this.name=name;
      }
      public Father(int age){
      this.age=age
      }
      public Father(int age,String name){
      this.age=age;
      this.name=name;
      }  
 }

重写

public class OverLoad {
   public static void main(String args[])
   {
       add(1,2);
       add(2,3,4);
       add(1,2,3,4);
       System.out.println(add(1,2));
       System.out.println(add(2,3,4));
       System.out.println(add(1,2,3,4));

   }
   public  static int add(int a,int b)
   {
       return a+b;
   }
   public static int add(int a,int b,int c)
   {
       return a+b+c;
   }
   public static int add(int a,int b,int c,int d)
   {
     return a+b+c+d;  
   }
}

重载

 class Father {
  public  int age=12;
   String name;

   public  void makeMonkey(){
       System.out.println("我要赚钱");
   }
}
class Son extends Father{
    public int age=15;
    @Override
   public  void makeMonkey(){
       System.out.println("我要赚很多钱钱");
   }
}

4)this,super,final ,abstract,static 等关键字

①this关键字
1.this表示在构造函数中，表示使用该构造函数创建的对象
2.this在实例方法中，表示调用当前方法的对象


class Person{
    int age;
    String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
 class Student extends Person {

    public Student()
    {

    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void eat()
    {
        System.out.println(age);
    }
    public void study(){
        System.out.println("学生很能学");
    }
    public void playGames(){
        System.out.println("学生很能玩");
    }
}

②super关键字
1. 子类不继承父类的构造方法.因此，子类如果要调用父类的构造方法必须在子类的构造方法中使用，必须使用关键字super来表示。
注：子类中如没有明显的写出super关键字来调用父类的某个构造方法，则默认为super();
2. 使用super操作被子类隐藏的成员变量和方法。

class Father {
    public int sa = 22;
}

class Son extends Father {
    public int sa = 121;

    Son() {
    this.sa = super.sa;
    }
}

class UseSon {
    public static void main(String[] args) {
        Son son = new Son();
        System.out.println(son.sa);
    }
}

③final
final表示“最终”
final在类之前：表示该类不能被继承
final在方法之前：表示该方法不能被覆盖
final在变量之前：对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
final类：

    public final class FinalClass {
    //这是常量定义，表示值不可更改
    public final double PI=3.1415;
    }
    //子类不可以继承final类
    /*
    class SubFinalClass extends FinalClass{
    }
    */

final方法：

 public class FinalMethod {
    //方法不能在子类中被重写
    public final double Division() {
        return 1.0;
    }
    }
    //演示子类不可重写final方法
    class SubFinalMethod extends FinalMethod{
    /*
    @Override
    public double Division() {
        // TODO Auto-generated method stub
        return super.Division();
    }*/
    }

④abstract
abstract表示”抽象”
1.abstract修饰类：abstract不能用new创建对象；

2.但是它的非抽象子类必须重写父类的抽象方法，给出方法体；
abstract也可没有abstract方法；

public class UseAbstract {
  public static void main(String[] args){
      Circle circle=new Circle(3.121);
      double area=circle.getArea();
      double length=circle.getLength();
      System.out.println(length+" "+area);
      Rect rect=new Rect(24.1,214.21);
      double length1=rect.getLength();
      double area1=rect.getArea();
      System.out.println(length1+" "+area1);

  }
}
abstract class MyShape{
 abstract double getLength();
 abstract double getArea();
}
class Circle extends MyShape{
    double pi=3.14;
    double r;
    Circle(){

    }
    public double getPi() {
        return pi;
    }
    public void setPi(double pi) {
        this.pi = pi;
    }
    public double getR() {
        return r;
    }
    public void setR(double r) {
        this.r = r;
    }
    Circle(double r){
        this.r=r;
    }
    @Override
    double getLength() {
        // TODO Auto-generated method stub
        return 2*pi*r;
    }
    @Override
    double getArea() {
        // TODO Auto-generated method stub
        return pi*r*r;
    }

}
class Rect extends MyShape{
    double length;
    double width;
    Rect(){

    }
    Rect(double length,double width){
        this.length=length;
        this.width=width;
}
    @Override
    double getLength() {
        // TODO Auto-generated method stub
        return 2*length+2*width;
    }
    @Override
    double getArea() {
        // TODO Auto-generated method stub
        return length*width;
    }

}

⑤static
static在变量或方法之前，表明他们属于类范围的，称为类方法（静态方法）或类变量（静态变量）
若变量或方法之前无static修饰，则是实例方法和实例变量
1 .静态属性：
类变量在各个实例间共享
类变量的生存期不依赖于对象，相当于c语言中的全局变量的作用，其他类可以不通过实例化访问他们。

public class StaticVar {
        public static int number=3;

    }
    public class OtherClass {
        public void method() {
            int x=StaticVar.number;
    }

    }

2）、静态方法：
类方法相当于C语言中的全局函数，其他类不用实例化即可调用他们。

   public class GeneralFunction {
    public static int addUp(int x,int y) {
        return x+y;
    }
    }
    public class UseGeneral {
    public void method() {
        int a=9;
        int b=10;
        int c=GeneralFunction.addUp(a, b);
    }
    }

3）、静态变量/方法和实例变量/方法
静态变量/方法都是使用类名引用
实例变量/方法必须先创建实例对象，然后使用实例对象引用

   public class StaticAndInstanceDemo {
    private int id=1;  //实例变量
    public static int number=3; //静态变量

    public int getId() {  //实例方法
        return this.id;
    }

    public static int addUp(int x,int y) { //静态方法
        //this.id;     //在静态方法中不能使用this
        return x+y;  //在静态方法中只能访问静态变量或者静态方法
    }

    }

4.完整例子


    //static是违反了面向对象原则的。
    //所有静态变量、静态方法的使用都不需要创建对象实例
    public class StaticClass {
    //静态代码块
    //这些代码在加载类的字节码后立即执行，不需要创建对象实例
    static {
        System.out.println("static block 2");
    }
    static {
        System.out.println("static block 1");
    }
    //静态变量保存在方法区，由所有的对象实例所共享
    //静态变量类似于全局变量，在并发环境中会出现同步问题。
    //在面向对象编程中不应该使用静态变量，如果要使用static修饰变量，通常和final配对使用来定义常量。
    public static final double PI=3.1415;
    private int i;

    public StaticClass() {
        System.out.println("构造方法被调用");
    }

    //静态方法
    //直接使用“类名.静态方法名”调用
    //静态方法中不可以使用this，因为它执行时并不需要对象存在。
    public static void method1() {
        System.out.println("静态方法被调用");
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("StaticClass.PI:"+StaticClass.PI);
        StaticClass.method1();
    }

    }

5) 内部类

在面向对象程序设计中，可以在一个类的内部定义另一个类，即内部类；
内部类有两种类型：静态内部类、非静态内部类（普通内部类），静态内部类使用很少，最重要的是普通内部类
1、普通内部类：
内部类几乎可以处于内部的任意位置，可以与实例变量处于同一级，或处于方法之类，甚至是一个表达式的一部分。
普通内部类和平时的类定义没有什么不同，主要是内部类可以访问外部类的属性和方法，这里的语法和平时有些不同

普通类的定义：

public class Forest {
    //成员变量
    private int sum_tree=1000; //树的总数
    private int type_tree=100; //树的类型

    //成员方法
    public int getTreeType() {
        return type_tree;
    }

class MagicalAnimal{
        private String name;  //动物名称

        public void setName(String name) {
            this.name=name;
        }

        public int getTreeSum() {           
            return Forest.this.sum_tree;
        }

        public int getTreeType() {
            return Forest.this.getTreeType(); 
        }
    }
    }
    public class ForestClient {


    public static void main(String[] args) {
    Forest.MagicalAnimal man=new Forest().new    MagicalAnimal();
        man.setName("Monkey"); 
        System.out.println(man.getTreeSum());
        System.out.println(man.getTreeType());
    }
    }

6) Obeject的一些常见方法

Object是Java类层次中的根类，所有的Java类（包括数据）的最终父类一定是Object。
①toString()：表示对象的特征；返回一串字符串
注：一般toString()需要重写
②equals，hashCode() ，==：判断对象是否相等
注：1.==,equal(再补重写时)比较的是地址
2.hasCode()返回的是一个地址转换的整数
3.equals与hashCode()常需要重写
③getClass()：获取创建对象的类信息。例如：类定义，属性定义，方法定义等。

 `public class UseObjectFunction {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
     Student s1=new Student();
     s1.setAge(12);
     s1.setName("郜哦");
     System.out.println(s1.hashCode());

     Student s2=new Student();
     s2.setAge(12);
     s2.setName("郜哦");
     System.out.println(s1==s2);
        System.out.println(s1.equals(s2)); 
      System.out.println(s2.getClass().getName());  
    } 

}
class Student{
    int age;
    String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student [age=" + age + ", name=" + name + "]";
    }
//  @Override
//  public int hashCode() {
//      final int prime = 31;
//      int result = 1;
//      result = prime * result + age;
//      result = prime * result + ((name == null) ? 0 : name.hashCode());
//      return result;
//  }
//  @Override
//  public boolean equals(Object obj) {
//      if (this == obj)
//          return true;
//      if (obj == null)
//          return false;
//      if (getClass() != obj.getClass())
//          return false;
//      Student other = (Student) obj;
//      if (age != other.age)
//          return false;
//      if (name == null) {
//          if (other.name != null)
//              return false;
//      } else if (!name.equals(other.name))
//          return false;
//      return true;
//  }

}`