JAVA面向对象

作者: joytom | 来源:发表于2019-03-27 14:44 被阅读0次

一、成员变量和局部变量区别

1、作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类的内部都是可见的

package com.haha;

public class imooc_3_5_duixiang {
    public static void main(String[] args) {
        imooc_3_5_duixiangs i=new imooc_3_5_duixiangs();
        i.show();
        i.shows();
    }
}
class imooc_3_5_duixiangs{
    int age;
    public void show() {
        int num=23;
        System.out.println(age);
    }
    public void shows() {
        System.out.println(num);
    }
}

定义了一个全局成员变量age，在show 中能执行，但在show方法中定义一个num局部变量，在shows中使用就报错了。因为num是局部变量。因此，在shows方法中不能使用

2、初始值不同

JAVA会给成员变量一个初始值（初始值为0），但JAVA不会给局部变量赋予初始值

3、
①在同一个方法中，不允许有同名的局部变量
②在不同的方法中，允许有同名的局部变量
4、

两类变量同名时，局部变量拥有最高级（就是优先使用局部变量的值）

二、构造方法

imooc_3_5_duixiang.java：

package com.haha;

public class imooc_3_5_duixiang {

    public imooc_3_5_duixiang() {
        System.out.println("调用无参数的构造方法");
    }
}

Ceshi.java：

package com.haha;
import com.haha.imooc_3_5_duixiang;
public class Ceshi {
    public static void main(String[] args) {
        new imooc_3_5_duixiang();
    }
}

运行结果：

image.png

三、static静态关键字（静态变量）

问题场景：当我们需要一个类中所有的对象都需要共享一个成员。这时，static关键字帮我们完美解决这个问题

image.png

四、static静态方法

1、静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如：

image.png

如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。如：

image.png

2、在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，如下所示：

image.png

3、静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。如：

image.png

五、static初始化静态方法块

案例一

image.png

image.png
案例二

image.png

总结：静态代码块优先级最高，

六、java中的内部类

内部类的主要作用如下：

内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以直接访问外部类的所有数据，包括私有的数据
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便

内部类可分为以下几种：

成员内部类
静态内部类
方法内部类
匿名内部类

//外部类HelloWorld
public class HelloWorld {
    
    // 内部类Inner，类Inner在类HelloWorld的内部
    public class Inner {
        
        // 内部类的方法
        public void show() {
            System.out.println("welcome to imooc!");
        }
    }
    
    public static void main(String[] args) {
        
        // 创建外部类对象
        HelloWorld hello = new HelloWorld();
        // 创建内部类对象
        Inner i = hello.new Inner();
        // 调用内部类对象的方法
        i.show();
    }
}

image.png

七、java中成员的内部类

image.png

image.png
友情提示：
1、外部类是不能直接使用内部类的成员和方法滴

image.png
可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

2、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如：

image.png

八、Java 中的静态内部类

1、静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员的方式访问

2、如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对象名= new 内部类();

image.png

九、Java 中的方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。

image.png

一定要注意哦：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

image.png

十、继承

继承的初始化顺序：
创建对象：

在创建对象的时候，优先创造父类对象、在创造子类对象

1、先初始化父类，在初始化子类。
2、先执行初始化对象中的属性，在执行构造方法中的初始化。

例子：

image.png

Animal.java

package two;

public class Animal {
    public int age=10;
    public Animal() {
        System.out.println("我是父类（动物类）中的构造方法");
        age=20;
    }
    public void eat() {
        System.out.println("我在父类（动物类）中吃东西");
    }
}

Cat.java

package two;

public class Cat extends Animal {
    public Cat(){
        System.out.println("我是子类（猫）中的构造方法");
    }
}

Mains.java

package two;

public class Mains {
    public static void main(String[] args) {
        Animal animal=new Animal();
        System.out.println("动物的年龄为"+animal.age);
//      Cat e=new Cat();
//      e.eat();
    }
}

执行结果：

image.png

Mains.java

package two;

public class Mains {
    public static void main(String[] args) {
//      Animal animal=new Animal();
//      System.out.println("动物的年龄为"+animal.age);
        Cat e=new Cat();
        e.eat();
    }
}

image.png

十一、final关键字的使用

使用场景：

final关键字可以修饰类、方法、属性和变量，如果final关键字修饰类，则该类不能被继承，如果final关键字修饰方法，则该方法不能被重写，final关键字如果修饰属性，则不会自动帮我们初始化（正常情况下，默认帮我们初始化，要么在构造方法中初始化，要么在声明属性的时候初始化，两者必选其一）如果在声明的时候已经初始化了，则其他地方则不能再对其初始化，final关键字输入声明变量，那么该变量只能赋一次值。

十二、super关键字的使用

1、super关键字可以调用父类中的构造方法、属性、方法。
Cat.java

package two;

public class Cat extends Animal {
    public Cat(){
        System.out.println("我是子类（猫）中的构造方法");
    }
    
    public void CeShi() {
        System.out.println(super.sex);
    }
}

Animal.java

package two;

public class Animal {
    final public int age=10;
    public String sex="男";
    public Animal() {
        System.out.println("我是父类（动物类）中的构造方法");
    }
}

子类中（Cat.java）中Ceshi方法来调用父类（Animal.java）中的sex属性。但是不能调用private修饰符修饰的成员属性。

调用父类中的方法（案例）：

package two;

public class Animal {
    final public int age=10;
    public String sex="男";
    public Animal() {
        System.out.println("我是父类（动物类）中的构造方法");
    }
    public void Dog() {
        System.out.println("我是父类中的小狗狗");
    }
}

Cat.java

package two;

public class Cat extends Animal {
    public Cat(){
        System.out.println("我是子类（猫）中的构造方法");
    }
    
    public void CeShi() {
        super.Dog();
        System.out.println(super.sex);
    }
}

其中，super.Dog()在使用super调用方法的时候，一定要放在首行，不然就会报错

2、
案例：

我在入口函数中调用子类中带参数的构造方法，又在子类带参数的构造方法中使用super关键字调用父类中的构造方法，如果super关键字里有参数，则调用父类中带参数的构造方法，如果super关键字里没有参数，则默认调用父类中没有带参数的构造方法。

mains.java

package two;

public class Mains {
    public static void main(String[] args) {
        Cat e=new Cat("哈特");
        e.CeShi();
    }
}

Cat.java

package two;

public class Cat extends Animal {
    public Cat(){
        super();    //调用无参数的
        System.out.println("我是子类（猫）中的构造方法");
    }
    
    public Cat(String name){
        super(name);    //调用有参数的
        System.out.println("我是子类（猫）中的带参数的构造方法"+super.sex);
    }                                          
    
    public void CeShi() {
        System.out.println(super.sex);
    }
}

Animal.java

package two;

public class Animal {
    final public int age=10;
//  private String name="欧文";
    public String sex="男";
    public Animal() {
        System.out.println("我是父类（动物类）中的构造方法");
    }
    public void Dog() {
        System.out.println("我是父类中的小狗狗");
    }
    public Animal(String name) {
        System.out.println("父类中的带参数的构造方法");
    }
}

3、
案例：
定义一个USB接口：

image.png

在定义一个子类来继承接口：

image.png
下面出现了这种情况：

image.png

正常情况下，接口中应该不能有构造方法对吧，为什么这样写不报错呢？

image.png

接口中是没有构造方法体的，子类中super调用的是object对象，因此不会报错。

我在eclipse使用快捷键自动在子类的构造方法中使用super调用，系统自动弹出了：

3.gif

总结：

子类的构造过程当中必须调用父类的构造方法。
如果子类中没有显示调用父类的构造方法，则系统默认调用父类中无参数的构造方法。
如果显示的调用构造方法，必须在子类构造方法的第一行。
如果子类构造方法中既没有显示的调用父类中的构造方法，父类中又没有无参的构造方法，那么就会报错了。

十三、setName和getName的使用

image.png

十四、多态

继承是多态的基础
1、引用多态

父类的引用可以指向子类的对象
子类的引用不能指向父类的对象
例如：

package duotai;

public class Mains {
    public static void main(String[] args) {
        Animal obj1=new Animal();
        Animal obj2=new Dog();  //父类的引用可以指向子类的对象
                                //以上既可以引用本类，又可以引用子类，这就是多态的体现
        //Dog obj3=new Animal();        //不能以子类的引用指向父类的对象，这是错误的方式
        
    }
}

标注：其中，Animal为父类，Dog为子类，Mains为主入口文件。
2、方法多态
案例一：
Animal.java

package duotai;

public class Animal {
    public void eat() {
        System.out.println("动物是世界上最可爱的语言");
    }
}

Dog.java

package duotai;

public class Dog extends Animal {
    public void eat() {
        System.out.println("小狗是世界上最可爱的语言");
    }
}

Mains.java

package duotai;

public class Mains {
    public static void main(String[] args) {
        Animal obj1=new Animal();
        Animal obj2=new Dog();  //父类的引用可以指向子类的对象
        obj1.eat();
        obj2.eat();
        //同样是父类引用，调用方法的时候，是指向不同方法，这是方法的多态
    }
}

image.png

同样是父类引用，调用方法的时候，是指向不同方法，这是方法的多态。

案例二：
在增加一个Cat.java，继承Animal类：
Cat.java

package duotai;

public class Cat extends Animal {
    
}

Mains.java

package duotai;

public class Mains {
    public static void main(String[] args) {
        Animal obj1=new Animal();
        Animal obj2=new Dog();  //父类的引用可以指向子类的对象
        Animal obj3=new Cat();
        obj1.eat();
        obj2.eat();
        obj3.eat();
        //同样是父类引用，调用方法的时候，是指向不同方法，这是方法的多态
    }
}

由于Cat类中没有eat方法，自动调用了父类中的eat方法。

案例三：
Mains.java

package duotai;

public class Mains {
    public static void main(String[] args) {
        Animal obj1=new Animal();
        Animal obj2=new Dog();  //父类的引用可以指向子类的对象
        obj1.eat();
        obj2.eat();
        obj2.bite();
        //同样是父类引用，调用方法的时候，是指向不同方法，这是方法的多态
    }
}

Dog.java

package duotai;

public class Dog extends Animal {
    public void eat() {
        System.out.println("小狗是世界上最可爱的语言");
    }
    
    public void bite() {
        System.out.println("狗是会咬人的");
    }
}

在Dog类中定义了bite方法，使用obj2调用，但是这样会报错，因为父类不能调用子类中独有的方法。

十五、抽象类

使用场景
1、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类该如何实现这些方法。
2、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

使用规则

abstract定义抽象类。
abstract定义抽象方法，只需要声明，不需要实现。
包含抽象方法的类是抽象类。
抽象类中可以包含普通方法，也可以没有抽象方法。

Telphone.java

package chouxiang;

public abstract class Telphone {
    public abstract void call();
    public abstract void message();
}

Smartphone.java

package chouxiang;

public class Smartphone extends Telphone {

    @Override
    public void call() {
        // TODO Auto-generated method stub
        System.out.println("通过语音打电话");
    }

    @Override
    public void message() {
        // TODO Auto-generated method stub
        System.out.println("通过语音发短信");
    }

}

Cellphone.java

package chouxiang;

public class Cellphone extends Telphone {

    @Override
    public void call() {
        // TODO Auto-generated method stub
        System.out.println("通过键盘来打电话");
    }

    @Override
    public void message() {
        // TODO Auto-generated method stub
        System.out.println("通过键盘来发短信");
    }

}

Mains.java

package chouxiang;

public class Mains {
    public static void main(String[] args) {
        Telphone tel1=new Cellphone();
        tel1.call();
        tel1.message();
        
        Telphone tel2=new Smartphone();
        tel2.call();
        tel2.message();
    }
}

image.png

十六、java中的字符串

1、创建java中的String对象

image.png

2、java中字符串的比较

package string;

public class Ceshi {
    public static void main(String[] args) {
        String s1="篮球";
        s1="小明正在操场打"+s1;
        System.out.println(s1);
    }
}

image.png
通过String s1声明了一个字符串对象，s1存放了到字符串对象的引用，在内存中的存放引用关系如下图所示：

JAVA面向对象

一、成员变量和局部变量区别

二、构造方法

三、static静态关键字（静态变量）

四、static静态方法

五、static初始化静态方法块

六、java中的内部类

七、java中成员的内部类

八、Java 中的静态内部类

九、Java 中的方法内部类

十、继承

十一、final关键字的使用

十二、super关键字的使用

总结：

十三、setName和getName的使用

十四、多态

十五、抽象类

十六、java中的字符串

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读