Java自学基础 面向对象（下）

最新推荐文章于 2022-12-01 11:18:03 发布
最新推荐文章于 2022-12-01 11:18:03 发布
阅读量138 收藏
点赞数
分类专栏： 学习笔记 自学笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/real_rookie/article/details/109221966
版权

Java面向对象（下）

前言

面向对象（上）
面向对象（中）
面向对象（下）

一、关键字：static

static:静态的

  1. 可以用来修饰的结构：主要用来修饰类的内部结构
    属性、方法、代码块、内部类

  2. static修饰属性：静态变量（或类变量）

    1. 属性，是否使用static修饰，又分为：静态属性(静态变量) vs 非静态属性(实例变量)

    实例变量：我们创建了类的多个对象，每个对象都独立的拥一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改。

    静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。

    1. static修饰属性的其他说明：
      1. 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
      2. 静态变量的加载要早于对象的创建。
      3. 由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。
      4. 访问权限允许时，可不创建对象，直接被类调用
class Circle{
	private double radius;
	public Circle(double radius){
		this.radius=radius;
	}
	public double findArea(){
		return Math.PI*radius*radius;
	}
}
创建两个Circle对象
Circle c1=new Circle(2.0); //c1.radius=2.0 
Circle c2=new Circle(3.0); //c2.radius=3.0

  • Circle类中的变量radius是一个实例变量(instance variable)，它属于类的每一个对象，不能被同一个类的不同对象所共享。

  • 上例中c1的radius独立于c2的radius，存储在不同的空间。c1中的radius变化不会影响c2的radius，反之亦然。

想让一个类的所有实例共享数据，这时候就出现了类变量！

类变量(class Variable)

  • 类变量（类属性）由该类的所有实例共享

类变量应用举例

class Person {
    private int id;
    public static int total = 0;

    public Person() {
        total++;
        id = total;
    }

    public static void main(String args[]) {
        Person Tom = new Person();
        Tom.id = 0;
        total = 100; // 不用创建对象就可以访问静态成员
    }
}


public class StaticDemo {
    public static void main(String args[]) {
        Person.total = 100; // 不用创建对象就可以访问静态成员
//访问方式：类名.类属性，类名.类方法
        System.out.println(Person.total);
        Person c = new Person();
        System.out.println(c.total); //输出101
    }
}

类方法(class method)

  • 没有对象的实例时，可以用类名.方法名()的形式访问由static修饰的类方法。
  • 在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构。
class Person {
    private int id;
    private static int total = 0;

    public static int getTotalPerson() {
//id++; //非法
        return total;
    }

    public Person() {
        total++;
        id = total;
    }
}

public class PersonTest {
    public static void main(String[] args) {
        System.out.println("Number of total is " + Person.getTotalPerson());
//没有创建对象也可以访问静态方法
        Person p1 = new Person();
        System.out.println("Number of total is " + Person.getTotalPerson());
    }
}
  • 因为不需要实例就可以访问static方法，因此static方法内部不能有this。(也不能有super!)
  • static修饰的方法不能被重写
class Person {
    private int id;
    private static int total = 0;

    public static void setTotalPerson(int total) {
        this.total = total; //非法，在static方法中不能有this，也不能有super
    }

    public Person() {
        total++;
        id = total;
    }
}

public class PersonTest {
    public static void main(String[] args) {
        Person.setTotalPerson(3);
    }
}

类属性、类方法的设计思想

  • 类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。
  • 如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用。

单例 (Singleton)设计模式

  • 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式免去我们自己再思考和摸索。就像是经典
    的棋谱，不同的棋局，我们用不同的棋谱-”套路”

  • 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。

单例(Singleton)设计模式-饿汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }

    // 2.内部提供一个当前类的实例
	// 4.此实例也必须静态化
    private static Singleton single = new Singleton();

    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        return single;
    }
}

单例(Singleton)设计模式-懒汉式

class Singleton {
    // 1.私有化构造器
    private Singleton() {
    }

    // 2.内部提供一个当前类的实例
// 4.此实例也必须静态化
    private static Singleton single;

    // 3.提供公共的静态的方法，返回当前类的对象
    public static Singleton getInstance() {
        if (single == null) {
            single = new Singleton();
        }
        return single;
    }
}
  • 单例模式的优点：
    由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后永久驻留内存的方式来解决。
  • 举例 java.lang.Runtime
    在这里插入图片描述

单例(Singleton)设计模式-应用场景

  • 网站的计数器，一般也是单例模式实现，否则难以同步。
  • 应用程序的日志应用，一般都使用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
  • 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。
  • 项目中，读取配置文件的类，一般也只有一个对象。没有必要每次使用配置文件数据，都生成一个对象去读取。
  • Windows的Task Manager (任务管理器)就是很典型的单例模式
  • Windows的Recycle Bin (回收站) 也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例

二、理解main方法的语法

  • 由于Java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为Java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。

  • 又因为main() 方法是静态的，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在之前的例子中多次碰到。

三、类的成员之四：代码块

  • 代码块(或初始化块)的作用：
    对Java类或对象进行初始化
  • 代码块(或初始化块)的分类：
    一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)，没有使用static修饰的，为非静态代码块。
  • static代码块通常用于初始化static的属性
class Person {
	public static int total;
	
	static {
	
	total = 100;//为total赋初值
	
	}
	…… //其它属性或方法声明
}
  • 静态代码块：用static 修饰的代码块
  1. 内部可以有输出语句
  2. 随着类的加载而执行,而且只执行一次
  3. 作用：初始化类的信息
  4. 如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
  5. 静态代码块的执行要优先于非静态代码块的执行
  6. 静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构
  • 非静态代码块：没有static修饰的代码块
  1. 内部可以有输出语句
  2. 随着对象的创建而执行
  3. 每创建一个对象，就执行一次非静态代码块
  4. 作用：可以在创建对象时，对对象的属性等进行初始化
  5. 如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
  6. 非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法

静态初始化块举例

class Person {
    public static int total;

    static {
        total = 100;
        System.out.println("in static block!");
    }
}

public class PersonTest {
    public static void main(String[] args) {
        System.out.println("total = " + Person.total);
        System.out.println("total = " + Person.total);
    }
}

总结：程序中成员变量赋值的执行顺序

在这里插入图片描述

四、关键字：final

  • 在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。
    • final标记的类不能被继承。提高安全性，提高程序的可读性。
      例如 String类、System类、StringBuffer类
    • final标记的方法不能被子类重写。
      比如：Object类中的getClass()。
    • final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。
      final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用。
final double MY_PI = 3.14;

final修饰类

final class A{
}
class B extends A{ 错误，不能被继承。
}

final修饰方法

class A {
    public final void print() {
        System.out.println("A");
    }
}

class B extends A {
    public void print() { 错误，不能被重写。
        System.out.println("尚硅谷");
    }
}

final修饰变量——常量

class A {
    private final String INFO = "atguigu"; //声明常量

    public void print() {
		报错：The final field A.INFO cannot be assigned  不能被修改
		INFO = "尚硅谷";
    }
}

常量名要大写，内容不可修改。

  • static final 用来修饰属性：全局常量

五、抽象类与抽象方法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

  • 用abstract关键字来修饰一个类，这个类叫做抽象类。
  • 用abstract来修饰一个方法，该方法叫做抽象方法。
    抽象方法：只有方法的声明，没有方法的实现。以分号结束：
    比如：public abstract void talk();
  • 含有抽象方法的类必须被声明为抽象类。
  • 抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
  • 不能用abstract修饰变量、代码块、构造器；
  • 不能用abstract修饰私有方法、静态方法、final的方法、final的类。

抽象类应用

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。

举例：

  • 在航运公司系统中，Vehicle类需要定义两个方法分别计算运输工具的燃料效率和行驶距离。
  • 问题：卡车(Truck)和驳船(RiverBarge)的燃料效率和行驶距离的计算方法完全不同。Vehicle类不能提供计算方法，但子类可以。
  • 解决方案
    Java允许类设计者指定：父类声明一个方法但不提供实现，该方法的实现由子类提供。
    这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。
  • Vehicle是一个抽象类，有两个抽象方法。
public abstract class Vehicle {
    public abstract double calcFuelEfficiency(); //计算燃料效率的抽象方法

    public abstract double calcTripDistance(); //计算行驶距离的抽象方法
}

public class Truck extends Vehicle {
    public double calcFuelEfficiency() { //写出计算卡车的燃料效率的具体方法
    }

    public double calcTripDistance() { //写出计算卡车行驶距离的具体方法
    }
}

public class RiverBarge extends Vehicle {
    public double calcFuelEfficiency() { //写出计算驳船的燃料效率的具体方法 
    }

    public double calcTripDistance() { //写出计算驳船行驶距离的具体方法
    }
}

注意：抽象类不能实例化 new Vihicle()是非法的

六、接口(interface)

  • 一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
  • 另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。
  • 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
  • 接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

举例：
在这里插入图片描述
在这里插入图片描述

  • 接口(interface)是抽象方法和常量值定义的集合。
  • 接口的特点：
    • 用interface来定义。
    • 接口中的所有成员变量都默认是由public static final修饰的。
    • 接口中的所有抽象方法都默认是由public abstract修饰的。
    • 接口中没有构造器。
    • 接口采用多继承机制。
  • 接口定义举例 ：左右等价
    在这里插入图片描述
  • 定义Java类的语法格式：先写extends，后写implements
class SubClass extends SuperClass implements InterfaceA{ }
  • 一个类可以实现多个接口，接口也可以继承其它接口。
  • 实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
  • 接口的主要用途就是被实现类实现。（面向接口编程）
  • 与继承关系类似，接口与实现类之间存在多态性
  • 接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。

应用举例：
在这里插入图片描述
在这里插入图片描述

interface Runner {
	public void start();
	public void run();
	public void stop();
}
class Person implements Runner {
	public void start() {
		// 准备工作：弯腰、蹬腿、咬牙、瞪眼
		// 开跑
	}
	public void run() {
		// 摆动手臂
		// 维持直线方向
	}
	public void stop() {
		// 减速直至停止、喝水。
	} 
}

interface MyInterface {
    String s = "MyInterface";

    public void absM1();
}

interface SubInterface extends MyInterface {
    public void absM2();
}

public class SubAdapter implements SubInterface {
    public void absM1() {
        System.out.println("absM1");
    }

    public void absM2() {
        System.out.println("absM2");
    }
}

实现类SubAdapter必须给出接口SubInterface以及父接口MyInterface中
所有方法的实现。否则，SubAdapter仍需声明为abstract的。

接口的应用：代理模式(Proxy)

概述：

代理模式是Java开发中使用较多的一种设计模式。代理设计就是为其他对象提供一种代理以控制对这个对象的访问。

  • 应用场景：
    • 安全代理：屏蔽对真实角色的直接访问。
    • 远程代理：通过代理类处理远程方法调用（RMI）
    • 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象比如你要开发一个大文档查看软件，大文档中有大的图片，有可能一个图片有100MB，在打开文件时，不可能将所有的图片都显示出来，这样就可以使用代理模式，当需要查看图片时，用proxy来进行大图片的打开。
  • 分类
    • 静态代理（静态定义代理类）
    • 动态代理（动态生成代理类）JDK自带的动态代理，需要反射等知识

接口和抽象类之间的对比

No.区别点抽象类接口
1定义包含抽象方法的类主要是抽象方法和全局常量的集合
2组成构造方法、抽象方法、普通方法、常量、变量常量、抽象方法、(jdk8.0:默认方法、静态方法)
3使用子类继承抽象类(extends)子类实现接口(implements)
4关系抽象类可以实现多个接口接口不能继承抽象类，但允许继承多个接口
5常见设计模式模板方法简单工厂、工厂方法、代理模式
6对象都通过对象的多态性产生实例化对象
7局限抽象类有单继承的局限接口没有此局限
8实际作为一个模板是作为一个标准或是表示一种能力
9选择如果抽象类和接口都可以使用的话，优先使用接口，因为避免单继承的局限

在开发中，常看到一个类不是去继承一个已经实现好的类，而是要么继承抽象类，要么实现接口。

Java 8中关于接口的改进

Java 8中，你可以为接口添加静态方法和默认方法。从技术角度来说，这是完全合法的，只是它看起来违反了接口作为一个抽象定义的理念。

静态方法： 使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。我们经常在相互一起使用的类中使用静态方法。你可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。

默认方法： 默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时，还保持了与旧版本代码的兼容性。比如：java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法

public interface AA {
    double PI = 3.14;

    public default void method() {
        System.out.println("北京");
    }

    default String method1() {
        return "上海";
    }

    public static void method2() {
        System.out.println("hello lambda !");
    }
}

接口中的默认方法

  • 若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现：接口冲突。
    解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。

  • 若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。

interface Filial {// 孝顺的

    default void help() {
        System.out.println("老妈，我来救你了");
    }
}

interface Spoony {// 痴情的

    default void help() {
        System.out.println("媳妇，别怕，我来了");
    }
}
class Man implements Filial, Spoony {
    @Override
    public void help() {
        System.out.println("我该怎么办呢？");
        Filial.super.help();
        Spoony.super.help();
    }
}

七、类的成员之五：内部类

  • 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

  • 在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。

  • Inner class一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。

    • Inner class的名字不能与包含它的外部类类名相同；

  • 分类：
    成员内部类（static成员内部类和非static成员内部类）

    局部内部类（不谈修饰符）、匿名内部类

  • 成员内部类作为类的成员的角色：

    • 和外部类不同，Inner class还可以声明为private或protected；
    • 可以调用外部类的结构
    • Inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

  • 成员内部类作为类的角色：

    • 可以在内部定义属性、方法、构造器等结构
    • 可以声明为abstract类 ，因此可以被其它的内部类继承
    • 可以声明为final的
    • 编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

【注意】

  1. 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
  2. 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
  3. 成员内部类可以直接使用外部类的所有成员，包括私有的数据
  4. 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

内部类举例

(1)

class Outer {
    private int s;

    public class Inner {
        public void mb() {
            s = 100;
            System.out.println("在内部类Inner中s=" + s);
        }
    }

    public void ma() {
        Inner i = new Inner();
        i.mb();
    }
}

public class InnerTest {
    public static void main(String args[]) {
        Outer o = new Outer();
        o.ma();
    }
}

(2)

public class Outer {
    private int s = 111;

    public class Inner {
        private int s = 222;

        public void mb(int s) {
            System.out.println(s); // 局部变量s
            System.out.println(this.s); // 内部类对象的属性s
            System.out.println(Outer.this.s); // 外部类对象属性s } }
            public static void main (String args[]){
                Outer a = new Outer();
                Outer.Inner b = a.new Inner();
                b.mb(333);
            }
        }
    }
}
  • 如何声明局部内部类
class 外部类 {
    方法() {
        class 局部内部类 {
        }
    }

    {
        class 局部内部类 {
        }
    }
}
  • 如何使用局部内部类
    • 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类
    • 但是它的对象可以通过外部方法的返回值返回使用，返回值类型只能是局部内部类的父类或父接口类型

局部内部类的特点

  • 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号，以及数字编号。
  • 只能在声明它的方法或代码块中使用，而且是先声明后使用。除此之外的任何地方都不能使用该类。
  • 局部内部类可以使用外部类的成员，包括私有的。
  • 局部内部类可以使用外部方法的局部变量，但是必须是final的。由局部内部类和局部变量的声明周期不同所致。
  • 局部内部类和局部变量地位类似，不能使用public,protected,缺省,private
  • 局部内部类不能使用static修饰，因此也不能包含静态成员

匿名内部类

  • 匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
  • 格式：
new 父类构造器（实参列表）|实现接口(){
//匿名内部类的类体部分
}
  • 匿名内部类的特点
    • 匿名内部类必须继承父类或实现接口
    • 匿名内部类只能有一个对象
    • 匿名内部类对象只能使用多态形式引用
interface A {
    public abstract void fun1();
}

public class Outer {
    public static void main(String[] args) {
        new Outer().callInner(new A() {
            //接口是不能new但此处比较特殊是子类对象实现接口，只不过没有为对象取名
            public void fun1() {
                System.out.println("implement for fun1 ");
            }
        });// 两步写成一步了
    }

    public void callInner(A a) {
        a.fun1();
    }
}

总结

本章主要讲述了关键字static、final、abstract、interface的使用，其中以面向对象体系中最后两个类，抽象类和接口最重要，这两个关键重点突出了多态和继承的特点
朱阿朱
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
继承、多态
zhaoying_ZY的博客
08-01 1035
继承 继承:需要定义独立的类,将其他类的共性内容抽取到该独立的类中,让其他类和这个独立类的产生一种关系: "继承"关系 继承的好处: 1)提供了代码的复用性 (代码结构清晰) 2)提供了了代码的维护性 3)类和类产生的这种"继承关系",是多态的前提条件 继承的关系也是一种弊端,类和类产生,耦合性就增强了 开发的原则:Java很多的开发原则都要遵循下面这个:低耦合,高内聚 耦合:尽量的一个类能完成的事情一个类去完成,不要产生过多的关系. (spring框架的IOC:控制反转)
JAVA基础，自学JAVA面向对象送达特性总结
最新发布
03-09
JAVA基础，自学JAVA面向对象送达特性总结
面向对象的C#语言——类的继承
Mr_Singto的博客
02-21 521
面向对象的C#语言——类的继承 使用继承的示例 ： 我们定义的窗体 public class Form1 : System.Windows.Forms.Form 其中“ : ”冒号代表继承 一、继承（inberitance） 子类subclass，父类baseclass C#中采用单继承 所有的类都是通过直接或间接地继承object(即system.object)得到的。 class sub...
子类到底能不能继承父类的私有属性？
学习 记录 总结 分享
08-17 8381
最后关于Java中子类能否继承父类的私有变量和方法？当然是以 Java 官方文档解释说明为准，这里我们明确一下“继承”一词的概念，在 Java 中，继承一词的意义是有限制的。一个子类只能继承其父类可访问的成员，并且该子类没有覆盖或者说隐藏父类中的那些可访问成员。所以，一个类的成员就是指在这个类中所声明的属性和方法，再加上从其父类继承而来的属性和方法。也就是说，子类是不能继承父类的私有成员的。虽然子类不继承父类中的私有成员，但是在父类中的这些私有成员仍然是子类对象的一部分。......
抽象abstract（一定要和子类发生继承关系）
m0_73030012的博客
08-16 209
一定要和子类发生继承关系（重写）现代的编程思想中大量使用抽象的类和方法作为系统构架模板。
子类能否访问或覆盖父类的private方法
走马观花
05-30 1万+
http://bettereveryday.iteye.com/blog/591771 private关键字的定义是“除了包含该成员的类之外,其他任何类都无法访问这个成员.”，也就是说只有自己才能直接访问到private成员，其他任何类，包括子类都无法访问到这个成员。   我们可以来测试一下： 定义两个类，Parent类和Child类 Parent类中有两个方法，一个public方法，一
2021Java零基础自学笔记资源（十二）Java面向对象
09-10
2021Java零基础自学笔记资源（十二）Java面向对象
Java面向对象知识点梳理(思维导图)
11-10
有一定Java基础的开发者可以通过导图巩固和扩展他们的知识，进一步提升面向对象编程的能力。 使用场景以及目标： 这个导图可以作为学习和复习Java面向对象编程的辅助工具。它可以用于自学、课堂教学、培训班等场景...
Java面向对象知识点的思维导图
11-10
有一定Java基础的开发者可以通过导图巩固和扩展他们的知识，进一步提升面向对象编程的能力。 使用场景以及目标： 这个导图可以作为学习和复习Java面向对象编程的辅助工具。它可以用于自学、课堂教学、培训班等场景...
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 第03章_面向对象编程(共100页).pptx
08-29
Java SE完整版精品优质课件 自学入门必看的优秀Java基础知识培训教案 特别适合新入门自学的新手同学，也适合老手回顾学习，巩固知识 第1章 Java语言概述 第2章 基本语法 第3章 面向对象编程 第4章 高级类特性1 第5...
Static修饰内部类
05-21
彦舜原创，CSDN首发：希望对你有所帮助，仅此而已。内容工整规范，是作者本人，逐句敲出来，同时也含有个人的一些独见。
关于子类多继承下，使用多态的问题
kkak1的博客
10-22 218
关于子类多继承下，使用多态的问题
java继承,子类构造方法赋值给父类对象
qq_39375211的博客
12-03 6737
java继承,子类构造方法赋值给父类对象,通过该对象访问方法和变量的不同情况说明
子类通过父类的构造函数为自己的属性字段赋值
feifeimomo521的专栏
05-11 960
1.当写好一个类以后，默认会存在一个没有参数的构造函数（即便我们不写构造函数，也会存在这么一个无参的构造函数） 2. 当手动添加一个构造函数以后，会将默认的无参数的构造函数覆盖掉。  3.类的构造函数是不能被继承的。只能在子类中去调用父类的构造函数。  4.当父类的构造函数有参数时，子类实例化时，要首先实例化父类（实例化完毕后才会实例化自己的属性），这个时候有错（子类无参数，父类有参数的问题
子类可以直接使用父类的变量、方法吗？
热门推荐
leng_wen_rou的博客
07-22 1万+
今天通过看嘉扬哥的代码 发现一个一直没注意到的问题：      子类可以直接使用父类的变量吗？     答案 ：可以 （只能是 protected  public 修饰的  成员变量）。     子类继承父类后 在方法里面可以直接使用父类的变量。  方法类似     注意：如果不是父类的成员变量就无法获取到。 做了个小实验： 父类：Parent
继承（java）
一枚数学专业的小码农的博客
06-04 2452
继承（java）
子类 到底能继承父类的哪些内容调用哪些内容
weixin_64651338的博客
12-01 3006
构造方法不能继承，方法的重写，this，super的使用
知识单元三 面向对象-2
qq_64314976的博客
07-14 1810
1. 设 x、 y为已定义的类名，下列声明x类的对象x1的语句中正确的是( )。 [单选题] *static x x1;public x x1=new x(int 123);y x1;x x1=new x( );(正确答案)2. 类的设计要求它的某个成员变量不能被外部类直接访问。应该使用下面的哪些修饰符获得需要的访问控制? [单选题] *public不加修饰符protectedprivate(正确答案)3. 为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，
【C++】子对象基础概念及其用法
皓皓松的博客
06-16 1万+
一、什么是子对象 二、子对象的作用是什么 三、利用子对象实现
2023java自学攻略
11-03
2. 学习面向对象编程（OOP）的概念，如类，对象，继承，多态等。 3. 学习Java标准库，如集合框架，输入/输出，异常处理等。 4. 练习编写Java程序，可以使用集成开发环境（IDE）如Eclipse或IntelliJ IDEA。 5. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值