JAVASE基础：面向对象

渔夫阿布

已于 2022-03-08 19:56:26 修改

阅读量116

点赞数

分类专栏： JVAVSE基础文章标签： java 开发语言后端

于 2022-03-01 20:47:17 首次发布

本文链接：https://blog.csdn.net/yu_fu_a_bu/article/details/123214802

版权

JVAVSE基础专栏收录该内容

38 篇文章 0 订阅

订阅专栏

面向对象

1. 面向对象与面向过程的区别（面向对象是基于面向过程的）
①面向对象将复杂的问题简单化
②万事万物皆可对象
③面向过程是执行者，面向对象是指挥者
2. 类和对象的关系
类：对具有相同属性和行为的事物的抽象
对象：实际存在的实体
类是对对象的描述，对象是类的实体

3. 类和对象的使用
①类的定义和使用
类的组成：属性和方法（成员变量和方法）

public class Student {
    //属性:成员变量
    //
    //方法:成员方法
    int age;
    String name;

    public void study(){
        System.out.println("学习");
    }
}

②对象的创建和调用成员变量和方法
创建对象：类名对象名 =new 类名（）；
调用成员变量
对象.成员变量
调用成员方法
对象.成员方法（）；

public class StudentTest {
    public static void main(String[] args) {
        //创建对象的格式
        //类名 对象名 = new 类名（）;
        Student s1=new Student();
        //说明：默认值，new就会开辟连续的空间
        System.out.println(s1.age);//0
        System.out.println(s1.name);//null
        System.out.println(s1);//com.ithema.object1.Student@1540e19d9(全类名：包名+类名+地址值)
        //对象的使用
        //对象名.属性
        //对象.方法名（）；
        s1.age=3;
        s1.name="张三";
        System.out.println(s1.age);
        System.out.println(s1.name);
        s1.study();


    }

}

4. 成员变量和局部变量的区别
在这里插入图片描述

5. private的使用

package com.ithema.private1;
/*
* 学生类
*
* */
public class Student {
    //成员变量
    private int age;
    private String name;
    //成员get/set方法
    public void setAge(int a){
        if(a<0){
            System.out.println("输入的值不合法");
        }else
        {
            age=a;
        }
    }
    public int getAge(){
        return  age;
    }
    public void setName(String n){
       name=n;
    }
    public String  getName(){
        return  name;
    }
    //show方法
    public void show(){
        System.out.println("age="+age+",name="+name);
    }

}

package com.ithema.private1;
/*
* 学生测试类
* */
public class StudentTest {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        //使用set方法给成员变量赋值
        s1.setAge(10);
        s1.setName("张三");
        //使用get方法获取成员变量的值
        System.out.println(s1.getAge()+","+s1.getName());
        System.out.println("********************");
        s1.show();
    }

}

结果
在这里插入图片描述

6. this关键字
在这里插入图片描述

7. 封装
在这里插入图片描述

8. 构造方法
作用：初始换对象
在这里插入图片描述

//构造方法
    public Student(){

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

9.标准类的制作
在这里插入图片描述

10.继承（面向对象的三大特征之一）

一，继承
1.1好处：提高代码的复用性，可扩展性
1.2语法：sub extends super
1.3使用的地方：
a.我们发现多个类中有相同的内容提取出一个父类
b.在写子类的时候，发现有父类可以继承
2.继承之成员变量
2.1父类中所有的成员变量都公被子类继承下去
如果父类中的成员变量是私有的，那么子类是不可以直接访问
2.2成员变量不重名
访问成员变量是没有影响的
2.3成员变量重名
this.成员变量–》就近原则(访问子类的成员变量)
super.成员变量–>访问父类的成员变量（不可以找爷爷的）

3.维承之成员方法
3.1成员方法不重复
访问成员方法是没有任何影响的
3.2成员方法重复(方法的重写–>覆盖)
为什么要有重写:对父类的方法进行升级
默认使用的是自己重写后的!
依然想用父类原本的
本类。通过super去调用父类的重复方法
其他类:没有直接的办法，调用到父类的eat
4.重写的条件
a.必须是父子类
b.方法名名必须相同
c.形参列表必须相同(个数、类型、顺序)
d.和返回值有关
object是string的父类
Animal是Cat的父类
基本数据米型返回值类型必须- -致,
对于引用数据类型来说，子类的要小于等于父类的
e.和权限修饰符有关
子类的要大于等于父类的
5.静态的方法是不允许被重写的
6继承的应用
6.1 this 调用属性
this.成员变量!调用的是谁的，看类型
this的类型是谁?就看this在哪个类中!
6.2 this调用方法
this.成员方法，调用的是谁的，看实际对象
this的实际对象是谁?看new的是谁!

import com.sun.media.jfxmediaimpl.HostUtils;

/*
* 父类*/
public class Animal {
    //公共属性
    public String name= "Animal";
    private int age;
    private String color;
    //构造器
    public Animal(){

    }
    public Animal(String name){
        this.name=name;
    }
    public Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public Animal(String name,int age,String color){
        this.age=age;
        this.name=name;
        this.color=color;
    }
    //getXxx   setXxx方法
    public void setName(String name){
        this.name=name;

    }
    public String getName(){
        return  name;
    }
    public  void setAge(int age){
        if(age<25||age>60){
            System.out.println("不合法");
        }else{
            this.age=age;
        }
    }
    public void setColor(){
        this.color=color;
    }
    public String getColor(){
        return color;
    }

    //吃的方法
    public void eat(){
        System.out.println("主类中吃饭");

    }
    //跑的方法
    public void run(){
        System.out.println("跑");
    }
}

//猫类继承Animal
public class cat extends Animal{
    //猫特有的属性
    private int rat;
    //get/set方法
    public void setRat(int rat){
        if(rat<10){
            System.out.println("AA");
        }else{
            this.rat=rat;
        }
    }
    public int getRat(){
        return rat;
    }
    public void climbtree(){
        System.out.println("爬树");
    }
}

//狗类继承Animal类
public class Dog extends Animal{
   // public String name="Dog";
    //狗类特有的看门方法
    public void eat(){
        System.out.println("dog类中吃饭");

    }
    public void supereat(){
        super.eat();
    }

    public void doorkeeper(){
        //子类和父类成员方法不重名
        System.out.println(this.name+"看门");

        //子类父类成员方法重名
        System.out.println(super.name+"看门");

    }

public class Teddy extends Dog{
    public String name = "Teddy";
    public void method(){
        //若父类和子类有相同的属性名this从本身开始找，然后父亲，然后爷爷
        System.out.println(this.name);
        //super从父辈开始找,如果父辈存在重名属性，那super是找不到爷爷的
        System.out.println(super.name);
        //若父辈没有重名属性是可以找到爷爷的重名属性的
        System.out.println(super.name);
    }

}

、

/*
* 测试类
* */
public class test {
    public static void main(String[] args) {
        //创建一个Dog对象
        Dog d1 = new Dog();
        //调用吃的方法
        d1.eat();
        d1.supereat();
        //调用跑的方法
        d1.run();
        //调用dog的成员方法
        d1.doorkeeper();
        //创建一个cat对象
        cat c1 = new cat();
        //调用cat类特有的属性，设置rat的值，并打印rat属性
        c1.setRat(45);
        System.out.println("rat="+c1.getRat());
        //调用cat类特有的属性
        c1.climbtree();
        Teddy t1 = new Teddy();
        t1.method();

    }
}

7.继承之构造器

①由于构造器的名称必须和类名- -致，所以子类是无法继承父类构造器的
。构造器的作用是初始化成员变量的
类加载的时候，是先加载父类在加载子类!
实例化子类对象的时候，父类空问优于子类对象的产生! (先执行父类的构造器，在执子类）
因为每一一个构造器的首行都默认存在一-行代码super() 默认调用父类无参、
要求:
super()如果显示的创建，也必须在首行
父类必存在无参构造器，否则默认情况会出错

/*
* person
*
* */
public class Person {
    //属性
    private String name;
    private int age;
    private String gender;
    //构造器
    public Person(){
        System.out.println("Person无惨构造器");
    }
    public Person(String name,int age,String gender){

        this.name=name;
        this.age=age;
        this.gender=gender;
        System.out.println("Person有参构造器");
    }
    //getXxx、setXxx方法
    public void setName(){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public void setGender()
    {
        this.gender=gender;
    }
    public String getGender(){
        return gender;
    }

}

public class Progremmer extends Person {
    private int salary;
    public Progremmer(){
        System.out.println("Progremmer无惨构造器");
    }
    public Progremmer(int salary){
        this.salary=salary;
        System.out.println(" Progremmer有参构造器");
    }
    public void setSalary(){
        this.salary=salary;
    }
    public int getSalary(){
        return salary;
    }
}

public class exer {
    public static void main(String[] args) {
        Progremmer p3 = new Progremmer();
        Progremmer p1 = new Progremmer(50000);
        Person p2 = new Person("张三" ,56,"男");
    }
}

在这里插入图片描述

11.多态

1.1对象多态性前提
●必须有继承或者是接口实现
●必须有方法的重写
多态的语法规则:父类或者接口的引用指向自己的子类的对象
父类变量(对象名)-
new子类对象(); //多态写法
对象调用方法,执行的子头的方法重写
1.2多态中成员的特点
●多态中成员变量的特点
。编译:父类中没有成员变量,编译失败
。运行:运行父类中的成员变量
●多态中成员方法的特点
。编译:父类中没有成员方法,编译失败
。运行:运行子类的方法重写
●简练:成员方法编译看左边，运行看右边.成员变量都是左边 I
Person p = new Student();

package com.sdjzu.code;
/*
* Person类*/
public class Person {

    //属性】
    public String s = "Person的属性";

    //吃的方法
    public  void eat(){
        System.out.println("Person吃饭");
    }
}

package com.sdjzu.code;

public class Student extends Person{

   public String s = "Student的属性";

    //Student的吃的方法
    public void eat(){
        System.out.println("Student吃饭");
    }
}

package com.adjzu.exer;

import com.sdjzu.code.Person;
import com.sdjzu.code.Student;

public class exer {
    public static void main(String[] args) {
        Person p1 = new Student();
        System.out.println(p1.s);
        p1.eat();
    }


}

1.4多态中的转型异常
异常ClassCastException类型转换异常,在多态中经常发生.
是在进行类型的强制转换的时候发生我们现在的案例是Student不能转成Pergresser.
需要解决这个异常:‘对象是什么就转什么
在这里插入图片描述
运算符:比较运算符结果是boolean类型
运算符是关键字instanceof
instanceof的语法格式:
对象名instanceof
类的名字
解析:比较这个对象，是不是由这个类产生的
C instanceof Cat
解释: C对象是不是Cat类产生的,如果是结果就是true
强制类型转换之前的安全性判断
练习
按要求实现下列问题:实现-一个名为Person的类和它的子
类Employee, Employee 有两个子类Faculty和Staff。具体
要求如下:。

Person类中的属性有:姓名name (String类型)，地址address (String类型)，。
电话号码telphone (String类型)和电子邮件地址email (String 类型) ;。
Employee 类中的属性有:办公室office (String 类型)，工资
wage
(doublev
类型)，受雇日期hiredate (String 类型) ;。
Faculty 类中的属性有:学位degree (String 类型)，级别level (String 类型) ;
Staff 类中的属性有:职务称号duty (String 类型)。。
5)现有对象 Person pl =new Faculty()和Person p2 =new Staff ()，请分别为p1的
属性赋值“木科”和Staff类的duty赋值“职员”。

package com.test;

public class Person {
    
    private String name;
    private String address;
    private String telphone;

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getTelphone() {
        return telphone;
    }

    public void setTelphone(String telphone) {
        this.telphone = telphone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    private String email;






}

package com.test;

public class Employee extends Person {
    private String office;
    private double wage;
    private String hiredate;

    public String getOffice() {
        return office;
    }

    public void setOffice(String office) {
        this.office = office;
    }

    public double getWage() {
        return wage;
    }

    public void setWage(double wage) {
        this.wage = wage;
    }

    public String getHiredate() {
        return hiredate;
    }

    public void setHiredate(String hiredate) {
        this.hiredate = hiredate;
    }
}

package com.test;

public class Faculty extends Employee{
   private String degree;
   private String level;

    public String getDegree() {
        return degree;
    }

    public void setDegree(String degree) {
        this.degree = degree;
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }
}

package com.test;

public class Staff extends Employee {
    private String duty;

    public String getDuty() {
        return duty;
    }

    public void setDuty(String duty) {
        this.duty = duty;
    }
}

package com.test;

public class test {
    public static void main(String[] args) {
        Person p1= new Faculty();
        if(p1 instanceof Faculty){
            Faculty f= (Faculty)p1;
            f.setDegree("本科");
            System.out.println("学历"+f.getDegree());

        }

        Person p2= new Staff();
        if(p2 instanceof Staff){
            Staff s= (Staff)p2;
            s.setDuty("职员");
            System.out.println(s.getDuty());
        }

    }
}

运行结果
在这里插入图片描述

渔夫阿布

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVASE基础：面向对象

面向对象1. 面向对象与面向过程的区别（面向对象是基于面向过程的）①面向对象将复杂的问题简单化②万事万物皆可对象③面向过程是执行者，面向对象是指挥者2. 类和对象的关系类：对具有相同属性和行为的事物的抽象对象：实际存在的实体类是对对象的描述，对象是类的实体类和对象的使用①类的定义和使用类的组成：属性和方法（成员变量和方法）public class Student { //属性:成员变量 // //方法:成员方法 int age; Strin
复制链接

扫一扫