面向对象（二）

最新推荐文章于 2024-10-14 20:18:07 发布
原创 最新推荐文章于 2024-10-14 20:18:07 发布 · 403 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式 #安卓

　　——- android培训、java培训、期待与您交流！ ———-

1. 代码块
在Java中，使用{}括起来的代码被称为代码块。
根据其位置和声明的不同，可以分为
局部代码块:局部位置,用于限定变量的生命周期。
构造代码块:在类中的成员位置,用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化。
静态代码块:在类中的成员位置,用{}括起来的代码,只不过它用static修饰了。
作用：一般是对类进行初始化。

面试题：静态代码块,构造代码块,构造方法的执行顺序

class Code {
    static {
        int a = 1000;
        System.out.println(a);
    }

    //构造代码块
    {
        int x = 100;
        System.out.println(x);
    }

    //构造方法
    public Code(){
        System.out.println("code");
    }

    //构造方法
    public Code(int a){
        System.out.println("code");
    }

    //构造代码块
    {
        int y = 200;
        System.out.println(y);
    }

    //静态代码块
    static {
        int b = 2000;
        System.out.println(b);
    }
}

class CodeDemo {
    public static void main(String[] args) {
        //局部代码块
        {
            int x = 10;
            System.out.println(x);
        }
        //找不到符号
        //System.out.println(x);
        {
            int y = 20;
            System.out.println(y);
        }
        System.out.println("---------------");

        Code c = new Code();    
        System.out.println("---------------");
        Code c2 = new Code();
        System.out.println("---------------");
        Code c3 = new Code(1);
    }
}

2. 继承

(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
这多个类就具备了这些内容。这个关系叫继承。
(2)Java中如何表示继承呢?格式是什么呢?
A:用关键字extends表示
B:格式：
class 子类名 extends 父类名 {}
(3)继承的好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类产生了一个关系，是多态的前提
(4)继承的弊端：
A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
原则：低耦合，高内聚。
耦合：类与类的关系
内聚：自己完成某件事情的能力
B:打破了封装性
(5)Java中继承的特点
A:Java中类只支持单继承
B:Java中可以多层(重)继承(继承体系)
(6)继承的注意事项：
A:子类不能继承父类的私有成员
B:子类不能继承父类的构造方法，但是可以通过super去访问
C:不要为了部分功能而去继承
(7)什么时候使用继承呢?
A:继承体现的是：is a的关系。
B:采用假设法
(8)Java继承中的成员关系
A:成员变量
a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?
子类的方法访问变量的查找顺序：
在子类方法的局部范围找，有就使用。
在子类的成员范围找，有就使用。
在父类的成员范围找，有就使用。
找不到，就报错。
B:构造方法
a:子类的构造方法默认会去访问父类的无参构造方法
是为了子类访问父类数据的初始化
b:父类中如果没有无参构造方法，怎么办?
子类通过super去明确调用带参构造
子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造
让父类提供无参构造
C:成员方法
a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢?
通过子类对象访问一个方法的查找顺序：
在子类中找，有就使用
在父类中找，有就使用
找不到，就报错

面试题：
Override和Overload的区别?Overload是否可以改变返回值类型?

方法重写：
    在子类中，出现和父类中一模一样的方法声明的现象。

方法重载：
    同一个类中，出现的方法名相同，参数列表不同的现象。


方法重载能改变返回值类型，因为它和返回值类型无关。


Override：方法重写
Overload：方法重载

this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

this:代表当前类的对象引用
super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)

场景：
    成员变量：
        this.成员变量
        super.成员变量
    构造方法：
        this(...)
        super(...)
    成员方法：
        this.成员方法
        super.成员方法

看程序写结果

class Fu{
    public int num = 10;
    public Fu(){
        System.out.println("fu");
    }
}
class Zi extends Fu{
    public int num = 20;
    public Zi(){
        System.out.println("zi");
    }
    public void show(){
        int num = 30;
        System.out.println(num); //30
        System.out.println(this.num); //20
        System.out.println(super.num); //10
    }
}
class ExtendsTest {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

A:成员变量 就近原则
B:this和super的问题
this访问本类的成员
super访问父类的成员
C:子类构造方法执行前默认先执行父类的无参构造方法
D:一个类的初始化过程
成员变量进行初始化
默认初始化
显示初始化
构造方法初始化

结果：
    fu
    zi
    30
    20
    10

3. final关键字
(1)是最终的意思，可以修饰类，方法，变量。
(2)特点：
A:它修饰的类，不能被继承。
B:它修饰的方法，不能被重写。
C:它修饰的变量，是一个常量。
(3)面试相关：
A:局部变量
a:基本类型 值不能发生改变
b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
B:初始化时机
a:只能初始化一次。
b:常见的给值
定义的时候。(推荐)
构造方法中。

4.多态
(1)同一个对象在不同时刻体现出来的不同状态。
(2)多态的前提：
A:有继承或者实现关系。
B:有方法重写。
C:有父类或者父接口引用指向子类对象。

多态的分类：
a:具体类多态
class Fu {}
class Zi extends Fu {}

Fu f = new Zi();
b:抽象类多态
abstract class Fu {}
class Zi extends Fu {}

Fu f = new Zi();
c:接口多态
interface Fu {}
class Zi implements Fu {}

Fu f = new Zi();
(3)多态中的成员访问特点
A:成员变量
编译看左边，运行看左边
B:构造方法
子类的构造都会默认访问父类构造
C:成员方法
编译看左边，运行看右边
D:静态方法
编译看左边，运行看左边

为什么?
因为成员方法有重写。
(4)多态的好处：
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
(5)多态的弊端：
父不能使用子的特有功能。

现象：
子可以当作父使用，父不能当作子使用。
(6)多态中的转型
A:向上转型
从子到父
B:向下转型
从父到子
(7)孔子装爹的案例帮助大家理解多态
(8)多态的练习
A:猫狗案例
B:老师和学生案例

/*
    多态练习：猫狗案例
*/
class Animal {
    public void eat(){
        System.out.println("吃饭");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃肉");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }
}

class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

class DuoTaiTest {
    public static void main(String[] args) {
        //定义为狗
        Animal a = new Dog();
        a.eat();
        System.out.println("--------------");
        //还原成狗
        Dog d = (Dog)a;
        d.eat();
        d.lookDoor();
        System.out.println("--------------");
        //变成猫
        a = new Cat();
        a.eat();
        System.out.println("--------------");
        //还原成猫
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
        System.out.println("--------------");

        //演示错误的内容
        //Dog dd = new Animal();
        //Dog ddd = new Cat();
        //ClassCastException
        //Dog dd = (Dog)a;
    }
}

5.抽象类
(1)把多个共性的东西提取到一个类中，这是继承的做法。
但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体。
也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
而一个没有具体的方法体的方法是抽象的方法。
在一个类中如果有抽象方法，该类必须定义为抽象类。
(2)抽象类的特点
A:抽象类和抽象方法必须用关键字abstract修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化
D:抽象类的子类
a:是一个抽象类。
b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。
(3)抽象类的成员特点：
A:成员变量
有变量，有常量
B:构造方法
有构造方法
C:成员方法
有抽象，有非抽象
(4)抽象类的练习
A:猫狗案例练习
B:老师案例练习
C:学生案例练习
D:员工案例练习
(5)抽象类的几个小问题
A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
用于子类访问父类数据的初始化
B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
为了不让创建对象
C:abstract不能和哪些关键字共存
a:final 冲突
b:private 冲突
c:static 无意义

/*
    猫狗案例
        具体事物：猫，狗
        共性：姓名，年龄，吃饭

    分析：从具体到抽象
        猫:
            成员变量：姓名，年龄
            构造方法：无参，带参
            成员方法：吃饭(猫吃鱼)

        狗:
            成员变量：姓名，年龄
            构造方法：无参，带参
            成员方法：吃饭(狗吃肉)

        因为有共性的内容，所以就提取了一个父类。动物。
        但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
        而方法是抽象的类，类就必须定义为抽象类。

        抽象动物类：
            成员变量：姓名，年龄
            构造方法：无参，带参
            成员方法：吃饭();

    实现：从抽象到具体
        动物类:
            成员变量：姓名，年龄
            构造方法：无参，带参
            成员方法：吃饭();

        狗类：
            继承自动物类
            重写吃饭();

        猫类：
            继承自动物类
            重写吃饭();
*/
//定义抽象的动物类
abstract class Animal {
    //姓名
    private String name;
    //年龄
    private int age;

    public Animal() {}

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

    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 abstract void eat();
}

//定义具体的狗类
class Dog extends Animal {
    public Dog() {}

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

    public void eat() {
        System.out.println("狗吃肉");
    }
}

//定义具体的猫类
class Cat extends Animal {
    public Cat() {}

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

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//测试类
class AbstractTest {
    public static void main(String[] args) {
        //测试狗类
        //具体类用法
        //方式1：
        Dog d = new Dog();
        d.setName("旺财");
        d.setAge(3);
        System.out.println(d.getName()+"---"+d.getAge());
        d.eat();
        //方式2：
        Dog d2 = new Dog("旺财",3);
        System.out.println(d2.getName()+"---"+d2.getAge());
        d2.eat();
        System.out.println("---------------------------");

        Animal a = new Dog();
        a.setName("旺财");
        a.setAge(3);
        System.out.println(a.getName()+"---"+a.getAge());
        a.eat();

        Animal a2 = new Dog("旺财",3);
        System.out.println(a2.getName()+"---"+a2.getAge());
        a2.eat();

        //练习：测试猫类
    }
}

6.接口
(1)回顾猫狗案例，它们仅仅提供一些基本功能。
比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，
是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
(2)接口的特点：
A:接口用关键字interface修饰
interface 接口名 {}
B:类实现接口用implements修饰
class 类名 implements 接口名 {}
C:接口不能实例化
D:接口的实现类
a:是一个抽象类。
b:是一个具体类，这个类必须重写接口中的所有抽象方法。
(3)接口的成员特点：
A:成员变量
只能是常量
默认修饰符：public static final
B:构造方法
没有构造方法
C:成员方法
只能是抽象的
默认修饰符：public abstract
(4)类与类,类与接口,接口与接口
A:类与类
继承关系，只能单继承，可以多层继承
B:类与接口
实现关系，可以单实现，也可以多实现。
还可以在继承一个类的同时，实现多个接口
C:接口与接口
继承关系，可以单继承，也可以多继承
(5)抽象类和接口的区别(自己补齐)?
A:成员区别
抽象类：
接口：
B:关系区别:
类与类：
类与接口：
接口与接口：
C:设计理念不同
抽象类：is a，抽象类中定义的是共性功能。
接口：like a，接口中定义的是扩展功能。
(6)练习：
A:猫狗案例，加入跳高功能
B:老师和学生案例，加入抽烟功能0

/*
    猫狗案例,加入跳高的额外功能

    分析：从具体到抽象
        猫：
            姓名,年龄
            吃饭，睡觉
        狗：
            姓名,年龄
            吃饭，睡觉

        由于有共性功能，所以，我们抽取出一个父类：
        动物：
            姓名,年龄
            吃饭();
            睡觉(){}

        猫：继承自动物
        狗：继承自动物

        跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
        接口：
            跳高

        部分猫：实现跳高
        部分狗：实现跳高
    实现；
        从抽象到具体

    使用：
        使用具体类
*/
//定义跳高接口
interface Jumpping {
    //跳高功能
    public abstract void jump();
}

//定义抽象类
abstract class Animal {
    //姓名
    private String name;
    //年龄
    private int age;

    public Animal() {}

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

    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 abstract void eat();

    //睡觉(){}
    public void sleep() {
        System.out.println("睡觉觉了");
    }
}

//具体猫类
class Cat extends Animal {
    public Cat(){}

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

    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//具体狗类
class Dog extends Animal {
    public Dog(){}

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

    public void eat() {
        System.out.println("狗吃肉");
    }
}

//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
    public JumpCat() {}

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

    public void jump() {
        System.out.println("跳高猫");
    }
}

//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
    public JumpDog() {}

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

    public void jump() {
        System.out.println("跳高狗");
    }
}

class InterfaceTest {
    public static void main(String[] args) {
        //定义跳高猫并测试
        JumpCat jc = new JumpCat();
        jc.setName("哆啦A梦");
        jc.setAge(3);
        System.out.println(jc.getName()+"---"+jc.getAge());
        jc.eat();
        jc.sleep();
        jc.jump();
        System.out.println("-----------------");

        JumpCat jc2 = new JumpCat("加菲猫",2);
        System.out.println(jc2.getName()+"---"+jc2.getAge());
        jc2.eat();
        jc2.sleep();
        jc2.jump();

        //定义跳高狗并进行测试的事情自己完成。
    }
}
/*
    老师和学生案例,加入抽烟的额外功能

    分析：从具体到抽象
        老师：姓名，年龄，吃饭，睡觉
        学生：姓名，年龄，吃饭，睡觉

        由于有共性功能，我们提取出一个父类，人类。

        人类：
            姓名，年龄
            吃饭();
            睡觉(){}

        抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口

        抽烟接口。

        部分老师抽烟：实现抽烟接口
        部分学生抽烟：实现抽烟接口

    实现：从抽象到具体

    使用：具体
*/
//定义抽烟接口
interface Smoking {
    //抽烟的抽象方法
    public abstract void smoke();
}

//定义抽象人类
abstract class Person {
    //姓名
    private String name;
    //年龄
    private int age;

    public Person() {}

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

    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 abstract void eat();

    //睡觉(){}
    public void sleep() {
        System.out.println("睡觉觉了");
    }
}

//具体老师类
class Teacher extends Person {
    public Teacher() {}

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

    public void eat() {
        System.out.println("吃大白菜");
    }
}

//具体学生类
class Student extends Person {
    public Student() {}

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

    public void eat() {
        System.out.println("吃红烧肉");
    }
}

//抽烟的老师
class SmokingTeacher extends Teacher implements Smoking {
    public SmokingTeacher() {}

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

    public void smoke() {
        System.out.println("抽烟的老师");
    }
}

//抽烟的学生
class SmokingStudent extends Student implements Smoking {
    public SmokingStudent() {}

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

    public void smoke() {
        System.out.println("抽烟的学生");
    }
}

class InterfaceTest2 {
    public static void main(String[] args) {
        //测试学生
        SmokingStudent ss = new SmokingStudent();
        ss.setName("林青霞");
        ss.setAge(27);
        System.out.println(ss.getName()+"---"+ss.getAge());
        ss.eat();
        ss.sleep();
        ss.smoke();
        System.out.println("-------------------");

        SmokingStudent ss2 = new SmokingStudent("刘意",30);
        System.out.println(ss2.getName()+"---"+ss2.getAge());
        ss2.eat();
        ss2.sleep();
        ss2.smoke();

        //测试老师留给自己练习
    }
}

抽象类和接口的区别：
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象

B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承

C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

　　——- android培训、java培训、期待与您交流！ ———-

面向对象的C++题目以及解法
u014114223的博客
04-09 1973
Description:自然数中，完数寥若晨星，请在从1到某个整数范围中打印出所有的完数来。而24不是完数，因为24≠1+2+3+4+6+8+12=36。Output:对于每个整数n，输出所有不大于n的完数。每个整数n的输出由n引导，跟上冒号，然后是由空格开道的一个个完数，每个n的完数列表应占独立的一行。一个整数n的因子数为包含它自身的所有因子的个数。例如：12的因子数为6(1,2,3,4,6,12)。Output:对于每个n，列出其所有因子数，每个n加上冒号单独列一行。
面向对象程序设计概念
kangjialong_的博客
11-02 2603
一. 程序设计范型   面向对象程序设计（object-oriented programming，OOP）是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格，它是一类程序设计语言的基础。 面向对象设计范型的主要特征是：  程序=对象+消息   面向对象程序的基本元素是对象。面向对象程序的主要结构特点是：一、程序一般由类的定义和类的使用两部分组成；二、程序中的一切操作都是向对象发送消息来实现的，对象收到消息后，启动有关方法完成相应的操作。   需要说明的是，某一种程序设计语言不一定与一种程
2017.8.8
qq_21198501的博客
08-08 266
面向对象+抽象+接口+object+String一些简单笔记
java基础面试题2--方法重写与重载、this和super关键字
a166244的博客
07-27 315
1：方法重写和方法重载的区别?方法重载能改变返回值类型吗? 方法重写： 　　　　　在子类中，出现和父类中一模一样的方法声明的现象。 方法重载： 　　　　　同一个类中，出现的方法名相同，参数列表不同的现象。 方法重载能改变返回值类型，因为它和返回值类型无关。 Override：方法重写 Overload：方法重载 面试题中很容易混淆这...
继承
bangbangdream的博客
10-01 195
继承、 概述 1.多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。 2.通过extends关键字可以实现类与类的继承 class 子类名 extends 父类名 {} 3.单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。 4.有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新...
如何实现面向对象
理想主义的花最终会盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
05-05 6562
如何实现面向对象面向对象的定义面向对象的三大特征、面向对象的基础实现面向对象基本准则实例 面向对象的定义 对象是指具体的某一事物，在现实生活中能够看得见摸得着的事物。在面向对象程序设计中，对象指的是计算机系统中的某一个成分。 在面向对象程序设计中，对象包含两个含义，其中一个是数据，另一个是动作。对象是数据和动作的结构体。 面向对象是在对象这一层次。 面向对象的三大特征、面向对象的基础 封装、继承、多态 封装：在面向对象中，对数据和动作进行包装，其中的某些数据动作，可以是私有的，不能被外界访问，以此来实现对数
Java面向对象浅谈
编程界明世隐的博客
12-06 5403
作者简介 作者名：编程界明世隐 简介：优快云博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
C 语言面向对象思想
lzs940320的博客
10-22 4025
注：本博客参考了很多大神的文章加上自己的理解，只做学习复习用 一. C语言面向对象设计引入 1.我们为什么要学习面向对象思想？？？ 在我们平时的开发中也经常会遇到一些简单的项目我们很快就完成了，并且测试着也没有任何问题，但是随着产品迭代，需求增加，项目维护起来越来越耗时，一个看似简单的需求，需要花费较多的时间去开发，出现项目延期。 项目超期的很大一部分原因都是因为代码“牵一发动全身”，当我们的项目需求在累加的过程中，功能相近的应用我们也习惯性的复制，粘贴。导致出现了很多的冗余代码，同时业务逻辑与执.
面向对象的编程思想
玄奕子的博客
06-24 1655
面向对象的编程思想
c++面向对象
m0_73297005的博客
10-14 2111
在c++中定义一个类一般格式如下：其中class为定义类的关键字，className为类的名字，{}中为类的主体。类中的元素称为类的成员：类中的数据称为类的属性或者成员变量；类中的函数称为类的方法或者成员函数。类成员具有不同的访问权限，其访问权限有三种：（1）public：该关键字用于修饰的成员表示公有成员，该成员不仅在类内可以被访问，在类外也可以被访问，是类对外提供的接口（2）private:修饰私有成员，私有成员在类内可以被访问，在类外是隐蔽的，体现了类的隐蔽性。
面向对象二
10-16
对于学java感到头疼的 出血者值得一看 吐血推荐
Python面向对象编程基础解析（二）
12-24
上一篇文章我们已经介绍了部分Python面向对象编程基础的知识，大家可以参阅：Python面向对象编程基础解析（一），接下来，我们看看另一篇。 封装 1.为什么要封装？ 封装就是要把数据属性和方法的具体实现细节隐藏...
PLC的面向对象编程
07-26
二、面向对象编程架构 面向对象编程架构需要在电路设计时考虑结构化设计，这包括自动线层、工程层和功能组层。自动线层通常包含一个主PLC，负责管理下属区域的控制；工程层没有PLC，但有独立的配电系统，通常包含...
《实验二 面向对象编程》
最新发布
03-06
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，其核心是使用“对象”来设计软件。在面向对象编程中，对象可以包含数据（以属性形式体现）和代码（以方法形式体现），并将其封装在一起。对象能够...
IO流---异常处理机制
movingleft的专栏
06-26 3103
——- android培训、java培训、期待与您交流！ ———- IO异常处理机制 异常就是可以预见的错误，java中所有的异常都从Throwable类中继承， 不过在一般情况下都会由 Exception 类派生出来。 异常分为两个部分： 错误：出现错误，只能终止程序 异常：出现异常，可以处理异常 异常又分为两种： 运行时期异常，是由程序员自身错误造成的，也称为未检查异常，例如空指针
java基础增强---JavaBean的内省操作
movingleft的专栏
06-27 523
8、IO8.2 IO流8.2.7 File类需求：获取c盘目录下的隐藏文件。代码：import java.io.File; import java.io.FilenameFilter; public class FileListDemo{ public static void main(String[] args){ listDemo(); } public static void list
API常见类
movingleft的专栏
06-22 459
5、多线程5.1 多线程的概念5.1.3 创建线程方式二：实现Runnable接口1. 定义类实现Runnable接口。 2. 覆盖接口中的run方法，将线程的任务代码封装到run方法中。 3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。所以要在线程对象创建时
网络编程
movingleft的专栏
07-05 455
——- android培训、java培训、期待与您交流！ ———- 1:网络编程 (1)网络编程：用Java语言实现计算机间数据的信息传递和资源共享 (2)网络编程模型(3)网络编程的三要素 网络编程三要素： A:IP地址 B:端口 C:协议举例: 我想和林青霞说话了。肿么办? A:我要找到林青霞。 B:对她说
java基础增强---Java 类加载器与动态代理
movingleft的专栏
07-01 442
8.2.11 IO包中的其他类需求：文件切割器。代码： 1. import java.io.File; 2. import java.io.FileInputStream; 3. import java.io.FileOutputStream; 4. import java.io.IOException; 5. import java.util.Properties; 6.
Java面向对象小程序案例解析
但是可以合理推断，文件列表中的“案例”二字可能指的是这个小程序作为教学或实践中的一个实例，用于帮助开发者更好地理解和掌握Java语言和面向对象的编程方法。 在学习和实践Java面向对象编程时，掌握这些基础知识...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值