java 面向对象

已于 2022-08-16 11:33:45 修改
阅读量169 收藏 1
点赞数 1
文章标签： java 开发语言
于 2022-08-13 16:54:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SUPERMarsR/article/details/126310189
版权

 形式参数分别为基本类型和引用类型的不同情况？
方法的形式参数如果是基本类型,实际参数该如何传递?

只需要在括号内输入基本类型数值即可

方法的形式参数如果是类(引用类型),实际参数该如何传递?

如果方法的形式参数是类,实际参数传递,需要传递的是当前类的具体类对象

匿名对象格式及好处:

格式  :   new  类名();

  1. 匿名对象可以作为参数传递,
  2. 匿名对象可以节省内存空间,因为没有栈内存空间,不需要开辟,直接开辟堆内存空间
  3. 匿名对象一般适用一次即可,适用完毕,直接被jvm的GC(垃圾回收器)回收

代码体现:

package com.qf.noname_04;

/**
 * Java中有一个概念:匿名对象: 毋庸置疑,没有名字对象;
 *     之前: 类名  对象名 =  new 类名() ; 对象名
 *     Student s = new Student() ;  里面的对象名是s
 *              对象名.访问成员方法();
 *
 *      匿名对象:
 *      格式:new 类名() ;
 *
 *              匿名对象调用方法
 *                      new  类名().成员方法名() ;
 *     好处:节省内存空间,new 类名() ;
 *     匿名对象可以作为参数传递
 *          创建完毕之后,没有栈内存指向,所以使用完毕,立即被GC(垃圾回收器回收)
 *      一般情况:匿名对象使用一次即可,这样不需要过多的去开辟堆内存空间,直接被回收;
 *
 *
 */
//学生类
class Student{
    public void study(){
        System.out.println("Good Good Study,Day Day Up!");
    }
}
//定义StudentDemo类
class StudentDemo{
    public void method(Student s){//形式参数是一个Student类型,引用类型
        s.study();//调用该方法,应该使用实际参数对象名在访问
    }
}
//测试类
public class NoNameDemo {
    public static void main(String[] args) {
            //要访问StudentDemo类中method方法
        //创建StudentDemo类对象|
        StudentDemo sd = new StudentDemo() ;
        //创建学生对象
        Student s = new Student() ;
        sd.method(s); //方法里面:形式参数 创建学生了学生对象
        System.out.println("---------------------------------");
        //使用匿名对象new  类名()
        //new  类名().成员方法名() ; //调用自己方法
        sd.method(new Student());
        System.out.println("---------------------------------");

        //再次优化:
        //链式编程(自己去玩,开发中很少)
        new StudentDemo().method(new Student());
    }
}

this关键字的概念以及目的

this:代表当前类对象的地址值引用

Student s=new Student();     s--->空间地址值引用

this的出现:        为了防止局部变量隐藏了成员变量

this的用法:

this.变量名;        变量名:访问本类的成员变量名

this.方法名();        访问的本类的成员方法

this();                  访问本类的无参构造方法

this(***);                访问本类有参构造方法

构造方法的特点和注意事项

构造方法的特点:

  1. 方法名和类名相同
  2. 没有具体返回值
  3. 连void都没有

构造方法的目的:就是为给类的成员初始化

Phone  p=new Phone();  --->无参构造方法

  1. 栈内存开辟空间
  2. 堆内存申请空间
  3. 进行系统默认初始化,为成员变量
  4. setXXX("xxx")   --->有参构造方法,显示初始化

构造方法的注意事项:

  1. 当在书写一个标准类的时候,没有给出任何构造方法.系统会默认提供无参构造方法
  2. 如果提供了一个类的有参构造方法,系统就不会构造方法,所以,建议永远给出无参构造方法;
  3. 构造方法是可以重载的

代码体现:

package com.qf.test;

public class PersonTest {
    public static void main(String[] args) {
        Person p=new Person("张三",33,173);
        Person p2=new Person("李四",44,174);
        p.sayHello();
        System.out.println("年龄:"+p.getAge()+",身高:"+p.getWeight());
        p2.sayHello();
        System.out.println("年龄:"+p2.getAge()+",身高:"+p2.getWeight());


    }
}
class Person{
    private String name;
    private  int age;
    private double weight;

    public Person() {
    }

    public Person(String name, int age, double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    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 double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
    public void sayHello(){
        System.out.println("hello my name  is"+name);
    }

}

一个类成员的组成以及一个类的标准写法

一个类的组成:

  1. 成员方法
  2. 成员变量
  3. 构造方法

一个标准类的写法:

  1. 成员变量私有化
  2. 无参永远给出,有参构造根据题意要求(没有明确,全部提供)
  3. 成员方法,根据题意要求(没有明确是否带参,是否有返回值,直接输出语句)

继承

概述:        将多个类的共性内容抽取出来,放在一个独立的类中,让这个独立的类和其他类产生一种关系--->继承  关键字extends

继承的特点:

  1. 在java语言中,类和类的关系是一种继承关系,这个继承只能支持单继承,不支持多继承但是支持多级继承

继承的好处:

  1. 可以提高代码的复用性
  2. 可以提高代码的维护性,后期便于维护,针对子类和父类进行维护(字符关系明确)
  3. 类与类产生继承关系,是多态的前提条件

注意事项:

  1. 子类继承父类,对于非私有的成员,直接可以继承过来,但是如果是私有成员,它可以通过公共的方法访问
  2. 被私有修饰的东西(成员变量/成员方法),只能在当前类访问

  在Java中有一个开发原则 "低耦合,高内聚"(以后所有的Java设计模式都需要遵循这一个原则)
            耦合性:开发中是永远避免不了,可以降低(耦合:类和类的关系)
            内聚性:指的是某个类完成某个功能的一种能力; 尽量不要产生继承关系来完成一个功         能,一个类能完成一个类完成;
            低耦合:降低耦合性,减少类和类的关系;

代码体现:

package com.qf.test;

public class PersonTest {
    public static void main(String[] args) {
        NorthPerson np=new NorthPerson("张三",24,"工人");
        System.out.println(np.getName()+"---"+np.getAge()+"---"+np.getProfession());
        np.eat();
        np.exam();
        SouthPerson sp=new SouthPerson("李四",25,"老师");
        System.out.println(sp.getName()+"---"+sp.getAge()+"---"+sp.getProfession());
        sp.eat();
        sp.business();

    }
}
class Person{
    private String name;
    private int age;
    private String profession;

    public Person() {
    }

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

    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 String getProfession() {
        return profession;
    }

    public void setProfession(String profession) {
        this.profession = profession;
    }
    public void eat(){
        System.out.println(name+"喜欢吃");
    }
}
class SouthPerson extends  Person{
    public SouthPerson() {
    }

    public SouthPerson(String name, int age, String profession) {
        super(name, age, profession);
    }

    @Override
    public void eat() {
        super.eat();
        System.out.println(super.getName()+"喜欢吃米饭");
    }
    public void business(){
        System.out.println(super.getName()+"喜欢经商");
    }
}
class NorthPerson extends  Person{
    public NorthPerson() {
    }

    public NorthPerson(String name, int age, String profession) {
        super(name, age, profession);
    }

    @Override
    public void eat() {
        super.eat();
        System.out.println(super.getName()+"喜欢吃面");
    }
    public void exam(){
        System.out.println(super.getName()+"喜欢考公");
    }
}

static关键字的特点:

  1. 被静态修饰的随着类的加载而加载,优先于对象的存在
  2. 不能和this共存
  3. 本身含义就是共享,共用,可以多个对象共享共用
  4. 被静态修饰的成员变量或者成员方法(静态变量,静态方法)访问的方式:

类名.变量名

类名.方法名

静态的使用场景以及适用范围:

静态方法中只能访问静态方法

静态方法只能调用静态方法

非静态方法皆可以访问静态的东西也可以访问非静态的东西

class Demo{
    int num = 10 ;//非静态的
    static int num2 = 20 ;//静态的

    //非静态的成员方法
    public void show(){ //非静态既可以调用静态/非静态方法
        System.out.println("show Demo");
        method(); //调用静态方法
        System.out.println(num2) ;
        System.out.println(num);
    }

    //静态的成员方法
    public static void method(){ //静态只能访问静态
        System.out.println("method Demo");
      //  show() ;
        System.out.println(num2);
       // System.out.println(num);//num是静态的
    }
}

//测试类
public class StaticDemo {
    public static void main(String[] args) {
        //访问num和num2 ---都可以使用对象来访问
        Demo d = new Demo() ;
        System.out.println(d.num) ;//10
       // System.out.println(d.num2) ;//20  //不推荐 对象名.变量名  num2静态的---属于类成员
        System.out.println(Demo.num2);//类名直接访问;

        System.out.println("-------------------------------------") ;
        //调用show()
        d.show();
        //d.method() ; //对象名.静态方法名()  可以的,idea不会提示  ;不推荐,静态方法随着类加载而加载
        //类名直接访问;
        Demo.method() ;

        System.out.println("---------------------");
        int result = add(10, 20); //main方法是静态的,main中调用其他方法必须静态,否则报错;
        System.out.println(result);
    }


    //自定义了一个方法
    public static int add(int a,int b){
        return  a+b ;
    }
}

继承关系中,构造方法的访问

子类继承父类,子类的所有构造方法都默认访问父类的无参构造方法

子类继承父类,会用到父类的数据,需要让父类先进行初始化(一个类的初始化,肯定需要执行构造方法的)

关键字super:

super:

代表父类的空间标识(代表父类的地址值引用)

this和super的区别:

this.变量名           访问本类的成员变量

super.变量名        访问父类的成员变量

this.方法名()        访问本类的成员方法

super.方法名()      访问父类的成员方法

this()                      访问本类无参构造方法

super()                  访问父类的无参构造方法

this(xxx)                访问本类的有参构造方法

super(xxx)             访问父类的有参构造方法 

注意:        子类继承父类,一定要先执行父类构造方法,初始化完毕之后,然后才能执行子类的构造方法---->分层初始化

实际开发中,常用到:

子类的无参构造方法----->默认父类无参构造方法

子类的有参构造方法----->直接访问父类的有参构造方法

静态代码块,构造代码块,构造方法的优先级

每次执行构造方法之前,如果存在构造代码块,先执行构造代码块

静态代码块,随着类的加载而加载,类加载一次,静态代码块执行一次

静态代码块>构造代码块>构造方法

继承中的方法重写

子类继承父类,成员变量的访问问题:

情况1: 子类和父类的中成员变量名称不一致,访问比较简单,分别访问即可!
情况2:子类和父类的成员变量名称一致:  如何访问呢?

  1.    先在子类的局部位置找,有没有这个变量,有就使用;
  2.    如果没有,在子类成员位置中找,有没有这个变量,有就使用;
  3.    如果子类的成员位置也没有,然后会在父类的成员位置找,有没有这个变量,有就使用;
  4.    如果父类的成员位置都没有,报错(前提:这个父类没有它的父类了),说明整个子父类中  都没有变量;
  5. 遵循"就近原则"

代码体现:

class Zi extends  Fu{
    //成员变量名称
    //int num2 = 30 ;

    //int num = 50 ;

    //子类的成员方法
   /* public void show(){
       // System.out.println(num) ;//访问父类的成员变量
      //  System.out.println(num2) ;//访问本类的成员变量
    }*/

    //method方法
    public void method(){
        //局部变量
        //int num = 100 ;
        System.out.println(num);
    }
}


//测试类
public class ExtendsDemo {
    public static void main(String[] args) {

        //创建子类对象
        Zi z = new Zi() ;
        //z.show() ;
        z.method();
    }
}

子类继承父类,成员方法的访问

情况1:子类和父类成员方法名称不一致,比较简单,分别调用即可

情况2:子类和父类的成员方法名称一致:权限修饰符,返回值类型,参数列表都一样

方法重写:

Override---->子类在父类的基础上,将父类的方法覆盖了,使用自己的功能

方法重写override和方法重载overload有什么区别?


方法重写:出现在继承中，描述的子类继承父类的时候,可能沿用父亲的功能,而且使用自己的功能,将父类的功能进行覆盖(复写/重写);为了让子类具体体现出来的功能信息

方法重载:定义方法的时候,方法名相同,参数列表不同,与返回值无关;目的为保证这个方法它的扩展性问题,同一个方法,可以不同类的参数;

代码体现:

//以前的手机
class Phone{
    public void callPhone(){
        System.out.println("手机可以电话了....");
    }
}
//新手机
class NewPhone extends  Phone{

    //子类将父类的方法覆盖了
    public void callPhone(){
        super.callPhone() ; //将父类的方法沿用了
        System.out.println("听音乐") ;
        System.out.println("玩游戏....");
    }
}

final关键字

final:        最终的,无法修改的,状态修饰符,被final修饰的成员方法不能被重写,保证父类的安全性

final可以修饰类,该类不能被继承

final可以修饰变量,此时这个变量是一个常量

final修饰成员方法,此时这个方法不能被子类重写,目的为了保证方法中某些数据的安全性

注意事项:

final修饰的变量只能被赋值一次,不能多次

final修饰基本类型,基本数据类型的值不能在改变

final修饰引用数据类型,引用数据类型:对象的地址值不能在改变

多态

宏观角度:一个事物在不同时刻体现的不同形态

微观角度:具体对象在内存中的变化(对象在不同时刻的类型)

多态的前提条件:

  1. 必须有继承关系
  2. 必须存在方法重写,子类部分功能将父类的功能进行覆盖,子类使用自己的功能体现
  3. 必须存在父类引用指向子类对象

例如:

        class Fu{}

        class Zi extends Fu{}

        向上转型:使用父类的东西

        父类名  对象名 =new 子类名();

        Fu fu=new Zi();    --->父类引用指向子类对象

        如果子类中由特有方法,使用强制类型转化

        Zi  zi   =(Zi)fu;

多态的成员访问特点:

父类名 对象名 =new  子类名();

成员变量:

                   编译看左,运行看左 ;
成员方法 :非静态
                   编译看左,运行看后, 因为子类重写了父类的功能!
 
                 静态方法:

                   即使子类出现了和父类一模一样静态方法,不算重写,因为静态方法都是自己类相关的,类成员!
                   编译看左,运行看左;

构造方法:多态的前提条件,有继承关系,跟继承一样,分层初始化
               先执行父类的构造方法,然后再是子类的构造方法
     

多态的弊端

 1.有继承关系了 2.有重写了 3.有父类引用指向子类对象 Fu f = new Zi() ;
       无法调用子类的特有功能!
   如何解决呢?
                   方案1:创建自己的子类对象
                   子类名 对象名 = new 子类名() ;
                   方案1不好地方:本身Fu fu = new Zi() ;已经开辟堆内存空间了,
                               Zi zi = new Zi();又要在堆内存开辟空间,消耗内存空间比较大 ;
 
                   方案2: 多态的第三个前提条件:父类引用指向子类对象
                   能不能将 将父类的引用 强制为子类的引用呢?
                    可以:
                   向下转型
                          前提必须向上转型Fu fu = new Zi() ;
                          Zi z  = (Zi)fu ;  //强转的语法
                         这样的好处:节省内存空间

代码体现:

package com.qf.test;
/*南方人和北方人都有姓名,年龄以及性别,职业,都有"吃饭"的功能,但是南方人经常吃米饭,北方人经常吃面条,
南方人主要还去经商,北方人主要考学,请使用继承的实现 使用代码实现(测试的时候使用多态进行测试)*/
public class PersonTest {
    public static void main(String[] args) {
        Person p=new NorthPerson("张三",21,"男","程序员");
        NorthPerson np=(NorthPerson)(p);
        np.eat();
        np.exam();
        Person p1=new SouthPerson("李四",22,"男","商人");
        SouthPerson sp=(SouthPerson) (p1);
        sp.eat();
        sp.jingshang();

    }
}

class Person{
    private String name;
    private int age;
    private  String sex;
    private String zhiye;

    public Person() {
    }

    public Person(String name, int age, String sex, String zhiye) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.zhiye = zhiye;
    }

    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 String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getZhiye() {
        return zhiye;
    }

    public void setZhiye(String zhiye) {
        this.zhiye = zhiye;
    }
    public void eat(){
        System.out.println(name+"吃...");
    }
}
class NorthPerson extends Person{
    public NorthPerson() {
    }

    public NorthPerson(String name, int age, String sex, String zhiye) {
        super(name, age, sex, zhiye);
    }

    @Override
    public void eat() {
        System.out.println(super.getName()+"吃面条");
    }
    public void exam(){
        System.out.println(super.getName()+"喜欢考学");
    }
}
class SouthPerson extends Person{
    public SouthPerson() {
    }

    public SouthPerson(String name, int age, String sex, String zhiye) {
        super(name, age, sex, zhiye);
    }

    @Override
    public void eat() {
        System.out.println(super.getName()+"喜欢吃米饭");
    }
    public void jingshang(){
        System.out.println(super.getName()+"喜欢经商");
    }
}

多态的好处:

  1. 提高代码的复用性,由继承保证
  2. 提高代码的扩展性,由多态保证:父类引用指向子类对象

代码体现:

//动物类
class Animal{
    public void eat(){
        System.out.println("动物都需要吃饭");
    }
    public void sleep(){
        System.out.println("动物都需要休息");
    }
}
//猫类
class Cat extends  Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼"); //重写了
    }

    @Override
    public void sleep() {
        System.out.println("猫躺着休息"); //重写了
    }
}
//狗类
class Dog extends  Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗侧着休息");
    }
}
class Pig extends  Animal{
    @Override
    public void eat() {
        System.out.println("猪吃白菜");
    }

    @Override
    public void sleep() {
        System.out.println("猪趴着休息");
    }
}
//这个类:封装使用猫或者狗的功能
class AnimalTool{
    //将构造私有化:  外界不能创建当期类对象--->只能提供外静态方法
    private AnimalTool(){}
   /* public static void userCat(Cat c){ //形式参数
        c.eat();
        c.sleep();
    }
    public static void userDog(Dog d){//形式参数
        d.eat();
        d.sleep();
    }

    public static void userPig(Pig p){//形式参数
        p.eat();
        p.sleep();
    }*/

    //多态的应用场景: 父类引用可以指向子类对象
    //方法的形式参数直接传递父类型                    //相当于这个方法形式参数 --->Animal a = new Cat();
    //方法的形式参数直接传递父类型                    //相当于这个方法形式参数 --->Animal a = new Dog();
    //方法的形式参数直接传递父类型                    //相当于这个方法形式参数 --->Animal a = new Pig();

    public static void userAnimal(Animal a) { //形式参数 父类类型,  父类名 对象名 = new 子类名();
        a.eat();
        a.sleep();
    }
}
//测试类
public class DuoTaiDemo {
    public static void main(String[] args) {
        //创建猫类对象
        //没有使用多态之前
        Cat cat = new Cat() ;
        cat.eat();
        cat.sleep();

        //养了一只狗,创建狗对象
        Dog dog = new Dog() ;
        dog.eat();
        dog.sleep();

        System.out.println("---------------------------------") ;
        //猫 吃/睡  狗 吃/睡
        //优化:方法的形式参数可以是引用类型   ,调用方法的时候,实际参数需要传递当前类对象
        // 定义静态的两个功能:userCat(Cat c) userDog(Dog d)

       // Cat c = new Cat() ;//创建猫对象
        //userCat(c); //实际参数:空间地址值

        // Dog d = new Dog() ;//创建狗对象
        //userDog(d); //实际参数:空间地址值

        //匿名对象可以作为参数传递
       // userCat(new Cat());

        //userDog(new Dog());
        System.out.println("-------------------------------");
        //如果子类型越来越多 pig,monkey....具体动物很多,会造成代码量大,单独提供userXXX功能(XXX类型)

        //学习了面向对象,应该将这些功能封装到一个类中,通过对象来访问或者静态方法,类名来访问
        //定义一个类AnimalTool
       /* Cat c = new Cat() ;
        AnimalTool.userCat(c);
       // AnimalTool.userCat(new Cat());
        Dog d = new Dog() ;
        AnimalTool.userDog(d); //实际参数

        AnimalTool.userPig(new Pig());*/

        //测试
        //多态的应用
        Animal a = new Cat() ;
        AnimalTool.userAnimal(a);


       // AnimalTool.userAnimal(new Cat());
        a = new Dog() ;
        AnimalTool.userAnimal(a);
        a = new Pig() ;
        AnimalTool.userAnimal(a);



    }
    //使用猫的功能
   /* public static void userCat(Cat c){ //形式参数
        c.eat();
        c.sleep();
    }
    public static void userDog(Dog d){//形式参数
        d.eat();
        d.sleep();
    }

    public static void userPig(Pig p){//形式参数
        p.eat();
        p.sleep();
    }*/

}

抽象类  abstract

在一个类中,如果有抽象方法,这个类必须是抽象类

抽象类中可以是抽象方法,可以是具体方法

抽象方法的格式:

和写方法的格式引用,加入一个关键字abstract,而且没有方法体{}

public abstract 返回值类型  方法名(空参/带参)

抽象类的特点:

  1. 不能实例化(不能创建对象)
  2. 必须强制子类完成方法重写

抽象类的子类:

        如果子类是一个抽象类,没有意义(抽象类new不了)(前提是这个子类没有它的子类)

        研究的抽象类的子类一定会有一个具体类,这个时候通过具体类才能创建对象

        抽象的父类名  对象名=new   具体的子类名();        //抽象类多态

抽象类的成员特点:

成员变量:抽象类的成员变量既可以是变量,也可以是自定义常量被final修饰

成员方法:抽象类中既可以有抽象方法,也可以有非抽象方法

构造方法:既可以定义无参构造方法,也可以是有参构造方法

存在抽象类多态,有继承关系,初始化的时候,构造方法----分层初始化---->先父类初始化,子类初始化

abstract 和那些关键字冲突
          和private关键字冲突:因为被private私有的成员方法只能在本类访问,而abstract修饰的成员方法
           必须强制子类重写,已经超出来的当前类的范围
 
           和final也冲突,被final修的成员方法,不能被重写;而抽象方法强制子类必须重写;
 
           和static也冲突,abstract修饰的方法必须被子类重写,而static修饰的方法,算不上抽象,直接跟类相关的;


           abstract关键字 应用范围: 定义在类上---抽象类
                               定义在方法上----抽象方法
                                           public abstract  返回值类型 方法名(空参/带参...)  ;
                                           abstract 返回值类型 方法/名(空参带参...)  ;

接口

接口特点

接口用关键字 interface 表示
格式： interface 接口名 {}
类实现接口用 implements 表示
格式： class 类名 implements 接口名 {}
接口不能实例化
那么，接口如何实例化呢 ?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。
接口的子类
要么是抽象类
要么重写接口中的所有抽象方法

接口成员的特点:

成员变量:
只能是常量
默认修饰符 public static fifinal---->可以省略
构造方法:
没有，因为接口主要是扩展功能的，而没有具体存在
成员方法:
只能是抽象方法
默认修饰符 public abstract

类与类,类与接口,接口与接口的关系

类与类
继承关系，只能单继承，但是可以多层继承
类与接口
实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口
接口与接口
继承关系，可以单继承，也可以多继承

抽象类和接口的区别:

成员区别
抽象类         变量, 常量;有抽象方法;非抽象方法,构造方法 ,
接口            常量;抽象方法(没有构造方法)
关系区别
类与类         继承，单继承
类与接口      实现，单实现，多实现
接口与接口   继承，单继承，多继承
设计理念区别
抽象类 被继承体现的是： ”is a” 的关系。共性功能
接口 被实现体现的是： ”like a” 的关系。扩展功能

附加:

成员变量和静态变量的区别?

位置不同:
成员变量    堆内存中
静态变量    方法区的静态区
初始化不同:
成员变量    和对象有关,将对象创建出来
静态变量    静态变量与类相关,称为类成员,初始化远远早于对象的创建
访问方式不同:
成员变量    类中方法外,随着对象的创建完毕,等待垃圾回收器回收而消失
静态变量    随着类的加载而加载,类加载一次静态的东西,具有共享性

SUPERMarsR
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java 继承 extends_java中的继承 (extends) 详解
weixin_33477290的博客
02-21 2569
继承(extends)1. 父类与子类父类也叫基类、超类 子类也叫派生类 在继承的而关系中，“子类就是一个父类“。也就是说，子类可以被当做父类来看待。例如父类是员工，子类是老师，那么我们可以说**”老师就是一个员工“**。 关系是“is - a”，例如“老师 is a 员工”2. 继承的格式2.1 定义父类的格式：(一个普通的类定义)public class 父类名称{//.....}2.2...
java面向对象编程pdf
04-16
Java面向对象编程PDF 在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为...
多态上
qq_52496081的博客
04-07 140
多态的概述：同一个对象在不同时刻表现出来的不同形态 例：猫 我们可以说猫就是猫：猫 cat = new 猫（）； 我们也可以说猫是动物：动物 animal = new 猫（）； 此时的猫在不同的时刻表现出来不同的形态，这就是多态 多态的前提和体现： 有继承/实现关系 有方法的重写 有父类引用指向子类对象 public class DuoTai { public static void main(String[] args) { Cat c = new Cat();
JavaSE基础加强之继承与多态(二)
zzq的博客
02-22 310
文章目录 (一)继承 (二)抽象类 (三)接口 (四)多态 (五)final关键字 (六)权限修饰符 (七)内部类
java继承
qq1032350287的博客
12-24 84
java继承–上转型对象 Fu fu=new Zi(); 关键字：方法重写有效，属性重新无效 public class Fu { String name="x"; int age=40; public Fu(){ System.out.println("fu 构造"); } void print (){ System.ou...
Java面向对象
weixin_73656077的博客
11-21 1895
Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下， 使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面 向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算 机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去 操作实现。面向对象的语言中，包含了三大基本特征，即封装、继承、多态。
JAVA面向对象
JINGJID的博客
03-25 4960
一、类与对象的创建 1.使用new关键字创建对象 Person person = new Person("Jingjing"); 二、构造器详解 一个类即使什么也不写，也会存在一个构造方法 即便前面的类是空的，仍然可以使用new方法创建一个对象 1.无参构造器和有参构造器 2.快捷方法 alt + insert :生成有参构造 alt +insert +seleteNone(弹出的中间）：生成无参构造 ...
java面向对象
热门推荐
黎小小的博客
08-21 4万+
本文内容是根据毕晓东老师的视频教程总结而得。包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能、行为 面向对象：将功能封装进对象，强调具备了功能的对象 面向对象是基于面向过程的 面向过程例子： ...
Java面向对象浅谈
编程界明世隐的博客
12-06 4920
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
Java面向对象基础
weixin_60719453的博客
10-13 8382
一、前言 我们上次学过java的方法，现在我们来学习新的一篇，也算是java中比较重要的一节了 面向对象基础是java中核心。 面向对象主要包括封装、继承、多态 我们这节主要讲的是封装，在这之前我们先来了解一下类和对象的定义和关系 什么是对象？ 世间一切都是对象，万物解释对象，对象就是看得见摸得着的东西。 什么是类？ 类是现实生活中对具有属性和行为同一类的总称。 类和对象的关系？ 类是对象的抽象化，对象是类的实例化 类的定义 ？ 类是java中的基本概念，java中
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
java 面向对象 案例 合集
07-18
java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 案例 合集java 面向对象 ...
匿名对象
weixin_30300225的博客
07-19 127
匿名对象 概念 创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量。虽然是创建对象的简化写法，但是应用场景非常有限。匿名对象 ：没有变量名的对象。 格式： new 类名(参数列表)； 应用场景 1. 创建匿名对象直接调用方法，没有变量名。 例如： new Scanner(System.in)； 2.匿...
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 216
从本地导入Junit
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 471
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 549
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Java面向对象编程详解
"Java面向对象编程的理论与实践" Java面向对象编程（Object-Oriented Programming，OOP）是现代软件开发中广泛采用的一种方法论。它的核心理念是“万物皆对象”，即现实世界中的任何事物都可以抽象为一个对象。在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SUPERMarsR

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值