JAVASE-面向对象(一)

头像
木安
    阅读 7 分钟

    1 面向对象概述

    所谓的面向对象是一种编程思想，通过这种思想可以把生活中的复杂事情变得简单化，从原来的执行者变成了指挥者，面向对象是基于面向过程而言的。

    我们经常说的面向对象的编程实现(OOP,Object Oriented Programming)

    三大特征

    • 封装性:把相关的数据封装成一个“类”组件
    • 继承性:是子类自动共享父类属性和方法，这是类之间的一种关系
    • 多态:增强软件的灵活性和重用性

    1.1 类与对象

    Java语言最基本单位就是类，类似于类型，类是一类事务抽象的介绍。
    对象是类的实例化。类似于，类是设计模板，对象是根据模板制造的具体东西。
    对象的特征：特征、属性、标识。

    public static void main(String[] args) {
        //创建对象，利用关键词new，调用类里的特征+行为
        phone p =new phone();//创建并使用        
        //对象对类里  属性+方法进行调用
        p.call();        
        System.out.println(p.size);                
    }
//创建了一个phone 类 ---用来描述特征+行为
class phone{
    //定义特征
    //类的成员变量/属性，在方法外创建；
    String size;
    double price;        
    //创建方法 ：修饰词 返回值 (参数列表){方法体} 
    public void call() {
        System.out.println("正在打电话");
    }
}

    1.2 构造方法

    概述:创建对象时自动调用构造方法

    作用:
    1、创建对象的创建(调用方法)。
    2、创建对象时对成员变量的初始化(成员变量赋值)。

    形式：

    //可以无参也可以有参
修饰符  类名(【参数】){
       代码……
}

    创建构造方法：

    class person{
    String name;
    int age;
    
    //如果没有设置无参构造，无参构造会被含参构造覆盖，则无法使用
    //默认无参的构造方法
    public  person() {
        System.out.println("无参构造");
    }    
    //含参构造
    public person(String n) {
        name=n;//利用含参构造直接赋值
        System.out.println("含参构造"+n);
    }
    //全参赋值
    public person(String n,int m) {
        name=n;
        age=m;
    }
}

    通过构造方法创建对象；
    通过含参构造方法完成对象初始化；

    person p =new person();//每次new时，都会调用构造方法里的内容
person p2 =new person("张三");//2、创建对象，会调用含参构造
person p3=new person("李四",20);//全参赋值

    总结：
    1,构造方法触发的时间点,,需要new来触发,不会自动执行。
    2,构造方法可以重载,为了方便各种new,提高程序的灵活性。
    3,构造方法在创建对象时会自动执行。

    注意:
    如果没提供无参构造,只提供了含参构造,无参构造会被覆盖,所以无参构造需提供;

    1.3 重载(overload)

    在一个类中，方法名都一样，但是参数列表(参数类型，数量等)不同的情况称为重载。

    package cn.tedu.methd;
//是指在一个类里发生的现象
//方法名都一样add,但是,参数列表不同
public class Test4_Overload {
    public static void main(String[] args) {
        long a = add(1,2);
        add(1,2,"jack");
    }
    public static long add(long a ,int b) {
        return a+b; //结束方法
    }
    //+可以用作加法也可以拼接
    public static void add(int a,int b,String c) {
        System.out.println(a+b+c); 
    }
}

    2 封装

    通过private关键,实现封装；为了提高程序的安全性,不让外界随意获取或者修改。

    用private修饰变量和方法：

    //创建一个student类，用来存储属性+行为/方法
class student{
    //属性--成员变量
    int sno;
    private String name;//成员变量被private
    //设置公共的修改方式---setXxx()
    public void setName(String n) {
        name = n;
    }
    //设置公共的查看方式---getXxx()
    public String getName() {
        return name;
    }
    
    //方法--成员方法
    //1、被privatex修饰，代表被私有化，只能在本类里使用
    private void call(){
        System.out.println("正在打电话");
    }
    public void eat() {
        System.out.println("正在吃饭");
    
    }
}

    类外调用访问：
    被private的变量，可以使用set和get方法初始化和访问。

    public static void main(String[] args) {
        //用new创建一个对象
        student s =new student();
        //赋值
        //s.name="张三";//2、被private,无法使用    
        s.setName("李四");//调用setName，进行初始化
        s.sno=90;
        //System.out.println(s.name);//2、被private,无法使用
        System.out.println(s.getName());
        System.out.println(s.sno);

        //调用功能
        //s.call();1、资源被private,无法调用
        s.eat();
    }

    3 继承

    概念:
    使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/基类。

    作用:
    提高代码的复用性,减少代码的编辑,提高开发效率。

    特点:

    • 使用extends关键字,子类把父类的功能复制了一份。
    • Java只支持单继承,可以传递,不能继承多个父类。
    • 不能继承父类的私有成员和构造方法。
    • 继承多用于功能修改-重写,子类拥有父类的功能的同时,也可以功能拓展。
    package text.oop;
//测试继承extends的使用
public class Test6_Extends {
    public static void main(String[] args) {        
        new Dog().eat();
        new Dog().sleep();//6,除了能用父类的功能,也可以进行功能拓展
        new Cat().sleep();//4,继承传递
    }
}
//1,创建父类--提取子类的共性--提高代码的复用性
class Animal{
    
    public Animal(){}
    //父类的私有成员不能被继承
    private int age;
    public void eat() {
        System.out.println("啥都吃");
    }
}
//2,创建子类,Dog类--子类想拥有父类的功能--需要发生继承关系--强耦合(不提倡)
class Dog extends Animal{
    //3,相当于把父类的功能复制了一边
        public void sleep() {
            int name = 20;
            super.eat();
            System.out.println("睡觉");
        }
}
//4,创建子类,Cat类--继承可以传递
class Cat extends Dog{    
}

    重写(override)
    概念:在继承中，当子类的功能和父类不一致时，子类可进行重写，针对继承的方法进行修改。
    要求:发生在继承中，子类的方法声明和父类的必须一致。
    方法声明([修饰符1 修饰符2...] 返回值类型 方法名(形参列表)(代码))

    注意：

    • 父类中的私有方法不能被重写。
    • 子类重写父类方法时，修饰符要大于等于父类修饰符的权限。

    继承中成员变量的继承：

    package test.oop;
//测试继承的使用super--成员变量
public class Test1_extends {
    public static void main(String[] args) {
        new Dog().call();
    }
}
//创建父类
class Animal{
    int count =50;
    int age = 30;
}
//创建子类
class Dog extends Animal{
    int num;
    int age =10;//创建成员变量
    public void call() {
        int age =20;//创建局部变量
        System.out.println(age);//20,就近原则
        System.out.println(num);//0,使用了默认值
        System.out.println(this.age);//10,this调用本类的成员变量
        System.out.println(super.count);//50,继承了父类的成员变量
        //1,super代表父类对象的引用,可以在子类中调用父类的成员变量
        //2,相当于super创建了一个新对象
        System.out.println(super.age);//30,用了父类的
//        Animal super = new Animal();
//        System.out.println(super.age);
    }
}

    继承中成员方法的继承：

    package test.oop;
//测试继承中super的使用---成员方法
//1,子类 继承父类的方法们--可以直接使用
//2,子类 自行扩展--可以拓展
//3,子类 可以修改继承来的方法--方法的重写
//4,需要改时才重写
public class Test2_extends2 {

    public static void main(String[] args) {
        new Zi2().eat();
        new Zi2().study();
        new Zi2().sleep();    
    }
}
//创建父类
class Fu2{
    public void eat() {
        System.out.println("父类吃");
    }
    public void study() {
        System.out.println("父类学");
    }
}
//创建子类,继承Fu2
class Zi2 extends Fu2{
    //3,方法的重写
    //要求:继承+子类的方法声明和父类的必须一致
    //方法声明([修饰符1 修饰符2...] 返回值类型  方法名(形参列表)(代码))
    public void eat() {
        //3.1,调用父类原来的eat()--重写并不影响父类的原有功能
//        super.eat();
        System.out.println("子类吃");
    }
    public void study() {
        System.out.println("子类学");
    }
    public void sleep() {//2,自行拓展
        System.out.println("子类睡");
    }
}

    继承中构造方法的继承：

    package test.oop;
//测试继承的构造方法
//总结:
//1,在子类的构造方法中,会隐藏这一行代码super()--调用父类的无参构造
//2,当创建子类对象时,会调用父类的构造方法,先执行父类的,再执行子类的
public class Test3_Extends3 {
    public static void main(String[] args) {
        new Zi3();//会先去执行父类的无参构造,再执行自己的    
    }    
}
//创建父类
class Fu3{
    public Fu3() {
        System.out.println("父类的无参构造");
    }
    public Fu3(int a) {
        System.out.println("父类的含参构造"+a);
    }    
}
//创建子类,继承Fu3
class Zi3 extends Fu3{
    public Zi3() {        
        //1,在子类的构造方法中,会隐藏这一行代码super()--
//        super();//会自动执行父类的无参构造--如果父类不提供无参构造会报错
//        super(5);//调用父类的含参构造--出现在构造方法里时,位置必须是第一行代码
        System.out.println("子类的无参构造");
    }
}

    4 多态

    概述：多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。

    好处：
    1,做出通用编程,本质上就是不关心具体的子类的类型,屏蔽了子类之间的不同,可以把子类当作父类来看。
    2,提高了程序的扩展性和可维护性。

    作用：
    多态的运用，提供了统一的调用标准--向父类看齐，功能向父类加，通用的功能向上提取，形成父类。

    特点：
    1,前提:1,发生继承关系,,2,发生重写
    2,父类引用指向子类对象,如Animal a = new Dog( ) ;
    3,编译(Ctrl +s)看左边,运行(Ctrl +F11)看右边
    image.png

    package test.oop;
//测试 多态的使用
//静态资源不存在重写,谁调用用谁的
public class Test8_DuoTai2 {
    public static void main(String[] args) {
        //创建多态对象  --- 父类引用 指向 子类对象
        Fu4 fu = new Zi4();
        //编译看左边,运行看右边
        System.out.println(fu.name);//成员变量用谁的?---父类的
        //多态中,方法声明用---父类的,,方法体用---子类的(因为重写了)
        fu.show();//成员方法用谁的?---子类的(重写了)
        fu.test();//成员方法用谁的?---父类的(没重写)
    }
}
class Fu4{
    String name = "赵的.四";
    public void show() {
        System.out.println("Fu4....show()");
    }
    final public void test() {
        System.out.println("Fu4......test()");
    }
        
}
class Zi4 extends Fu4{
    String name = "巴巴";
    public void show() {
        System.out.println("Zi4....show()");
    }
}
    java-se
    木安
    13 声望6 粉丝
    « 上一篇
    JAVASE-Basic(基础数据+运算符+分支/循环结构+数组)
    下一篇 »
    JAVASE-面向对象(二)

    引用和评论

    推荐阅读
    头像
    Spring Cloud-Eureka

    木安阅读 1.2k

    0 条评论
    得票最新